Nc/playground

.gitignore

@@ -158,3 +158,5 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
+
+.envrc

CONTRIBUTING.md

@@ -0,0 +1,51 @@
+# Contributing
+
+## Contributor License Agreement
+
+We are grateful to the contributors who help evolve LangServe and dedicate their time to the project. As the primary sponsor of LangServe, LangChain, Inc. aims to build products in the open that benefit thousands of developers while allowing us to build a sustainable business. For all code contributions to LangServe, we ask that contributors complete and sign a Contributor License Agreement (“CLA”). The agreement between contributors and the project is explicit, so LangServe users can be confident in the legal status of the source code and their right to use it.The CLA does not change the terms of the underlying license, LangServe License, used by our software.
+
+Before you can contribute to LangServe, a bot will comment on the PR asking you to agree to the CLA if you haven't already. Agreeing to the CLA is required before code can be merged and only needs to happen on the first contribution to the project. All subsequent contributions will fall under the same CLA.
+
+## 🗺️ Guidelines
+
+### Dependency Management: Poetry and other env/dependency managers
+
+This project uses [Poetry](https://python-poetry.org/) v1.6.1+ as a dependency manager.
+
+### Local Development Dependencies
+
+Install langserve development requirements (for running langchain, running examples, linting, formatting, tests, and coverage):
+
+```sh
+poetry install --with test,dev
+```
+
+Then verify that tests pass:
+
+```sh
+make test
+```
+
+### Formatting and Linting
+
+Run these locally before submitting a PR; the CI system will check also.
+
+#### Code Formatting
+
+Formatting for this project is done via a combination of [Black](https://black.readthedocs.io/en/stable/) and [ruff](https://docs.astral.sh/ruff/rules/).
+
+To run formatting for this project:
+
+```sh
+make format
+```
+
+#### Linting
+
+Linting for this project is done via a combination of [Black](https://black.readthedocs.io/en/stable/), [ruff](https://docs.astral.sh/ruff/rules/), and [mypy](http://mypy-lang.org/).
+
+To run linting for this project:
+
+```sh
+make lint
+```

Makefile

@@ -3,6 +3,12 @@
 # Default target executed when no arguments are given to make.
 all: help
 
+build-playground:
+	cd ./langserve/playground && yarn build
+
+build: build-playground
+	poetry build
+
 ######################
 # TESTING AND COVERAGE
 ######################

examples/chain/server.py

@@ -1,34 +1,73 @@
 #!/usr/bin/env python
 """Example LangChain server exposes a chain composed of a prompt and an LLM."""
+from typing import Any, Dict, List, Optional, Tuple
+
 from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
 from langchain.chat_models import ChatOpenAI
-from langchain.prompts import ChatPromptTemplate
-from typing_extensions import TypedDict
+from langchain.prompts import PromptTemplate
+
+# from typing_extensions import TypedDict
+from langchain.pydantic_v1 import BaseModel
+from langchain.schema.output_parser import StrOutputParser
+from langchain.schema.runnable import ConfigurableField, RunnablePassthrough
 
 from langserve import add_routes
 
-model = ChatOpenAI()
-prompt = ChatPromptTemplate.from_template("tell me a joke about {topic}")
-chain = prompt | model
+model = ChatOpenAI(temperature=0.5).configurable_alternatives(
+    ConfigurableField(id="llm", name="LLM"),
+    high_temp=ChatOpenAI(temperature=0.9),
+    low_temp=ChatOpenAI(temperature=0.1, max_tokens=1),
+    default_key="medium_temp",
+)
+prompt = PromptTemplate.from_template(
+    "tell me a joke about {topic}.\nChat history: {chat_history}"
+).configurable_fields(
+    template=ConfigurableField(
+        id="prompt",
+        name="Prompt",
+        description="The prompt to use. Must contain {topic}",
+    )
+)
+chain = (
+    RunnablePassthrough.assign(chat_history=(lambda x: "\n".join(x)))
+    | prompt
+    | model
+    | StrOutputParser()
+)
 
 app = FastAPI(
     title="LangChain Server",
     version="1.0",
     description="Spin up a simple api server using Langchain's Runnable interfaces",
 )
 
+# Set all CORS enabled origins
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+    expose_headers=["*"],
+)
+
 
 # The input type is automatically inferred from the runnable
 # interface; however, if you want to override it, you can do so
 # by passing in the input_type argument to add_routes.
-class ChainInput(TypedDict):
+class ChainInput(BaseModel):
     """The input to the chain."""
 
     topic: str
     """The topic of the joke."""
+    chat_history: List[str]
+    chat_history_tuples: List[Tuple[str, str]]
+    chat_history_object_list: List[Dict[str, str]]
+    tester: Optional[Dict[str, Any]] = None
 
 
-add_routes(app, chain, input_type=ChainInput)
+add_routes(app, chain, input_type=ChainInput, config_keys=["configurable"])
 
 # Alternatively, you can rely on langchain's type inference
 # to infer the input type from the runnable interface.

langserve/client.py

@@ -17,7 +17,7 @@
 
 import httpx
 from httpx._types import AuthTypes, CertTypes, CookieTypes, HeaderTypes, VerifyTypes
-from langchain.callbacks.tracers.log_stream import RunLog, RunLogPatch
+from langchain.callbacks.tracers.log_stream import RunLogPatch
 from langchain.load.dump import dumpd
 from langchain.schema.runnable import Runnable
 from langchain.schema.runnable.config import (
@@ -401,15 +401,14 @@ async def astream_log(
         input: Input,
         config: Optional[RunnableConfig] = None,
         *,
-        diff: bool = False,
         include_names: Optional[Sequence[str]] = None,
         include_types: Optional[Sequence[str]] = None,
         include_tags: Optional[Sequence[str]] = None,
         exclude_names: Optional[Sequence[str]] = None,
         exclude_types: Optional[Sequence[str]] = None,
         exclude_tags: Optional[Sequence[str]] = None,
         **kwargs: Optional[Any],
-    ) -> Union[AsyncIterator[RunLogPatch], AsyncIterator[RunLog]]:
+    ) -> AsyncIterator[RunLogPatch]:
         """Stream all output from a runnable, as reported to the callback system.
 
         This includes all inner runs of LLMs, Retrievers, Tools, etc.
@@ -436,7 +435,7 @@ async def astream_log(
             "input": simple_dumpd(input),
             "config": _without_callbacks(config),
             "kwargs": kwargs,
-            "diff": diff,
+            "diff": True,
             "include_names": include_names,
             "include_types": include_types,
             "include_tags": include_tags,
@@ -458,18 +457,12 @@ async def astream_log(
                 async for sse in event_source.aiter_sse():
                     if sse.event == "data":
                         data = simple_loads(sse.data)
-                        if diff:
-                            chunk = RunLogPatch(*data["ops"])
-                        else:
-                            chunk = RunLog(*data["ops"], state=data["state"])
+                        chunk = RunLogPatch(*data["ops"])
 
                         yield chunk
 
-                        if diff:
-                            if final_output:
-                                final_output += chunk
-                            else:
-                                final_output = chunk
+                        if final_output:
+                            final_output += chunk
                         else:
                             final_output = chunk
                     elif sse.event == "end":

langserve/playground.py

@@ -0,0 +1,47 @@
+import json
+import mimetypes
+import os
+from string import Template
+from typing import List, Type
+
+from fastapi.responses import Response
+from langchain.schema.runnable import Runnable
+
+try:
+    from pydantic.v1 import BaseModel
+except ImportError:
+    from pydantic import BaseModel
+
+
+class PlaygroundTemplate(Template):
+    delimiter = "____"
+
+
+async def serve_playground(
+    runnable: Runnable,
+    input_schema: Type[BaseModel],
+    config_keys: List[str],
+    base_url: str,
+    file_path: str,
+) -> Response:
+    local_file_path = os.path.join(
+        os.path.dirname(__file__),
+        "./playground/dist",
+        file_path or "index.html",
+    )
+    with open(local_file_path) as f:
+        mime_type = mimetypes.guess_type(local_file_path)[0]
+        if mime_type in ("text/html", "text/css", "application/javascript"):
+            res = PlaygroundTemplate(f.read()).substitute(
+                LANGSERVE_BASE_URL=base_url[1:]
+                if base_url.startswith("/")
+                else base_url,
+                LANGSERVE_CONFIG_SCHEMA=json.dumps(
+                    runnable.config_schema(include=config_keys).schema()
+                ),
+                LANGSERVE_INPUT_SCHEMA=json.dumps(input_schema.schema()),
+            )
+        else:
+            res = f.buffer.read()
+
+    return Response(res, media_type=mime_type)

langserve/playground/.eslintrc.cjs

@@ -0,0 +1,18 @@
+module.exports = {
+  root: true,
+  env: { browser: true, es2020: true },
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended',
+    'plugin:react-hooks/recommended',
+  ],
+  ignorePatterns: ['dist', '.eslintrc.cjs'],
+  parser: '@typescript-eslint/parser',
+  plugins: ['react-refresh'],
+  rules: {
+    'react-refresh/only-export-components': [
+      'warn',
+      { allowConstantExport: true },
+    ],
+  },
+}

langserve/playground/.gitignore

@@ -0,0 +1,26 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+
+.yarn

langserve/playground/README.md

@@ -0,0 +1,27 @@
+# React + TypeScript + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/README.md) uses [Babel](https://babeljs.io/) for Fast Refresh
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend updating the configuration to enable type aware lint rules:
+
+- Configure the top-level `parserOptions` property like this:
+
+```js
+   parserOptions: {
+    ecmaVersion: 'latest',
+    sourceType: 'module',
+    project: ['./tsconfig.json', './tsconfig.node.json'],
+    tsconfigRootDir: __dirname,
+   },
+```
+
+- Replace `plugin:@typescript-eslint/recommended` to `plugin:@typescript-eslint/recommended-type-checked` or `plugin:@typescript-eslint/strict-type-checked`
+- Optionally add `plugin:@typescript-eslint/stylistic-type-checked`
+- Install [eslint-plugin-react](https://github.com/jsx-eslint/eslint-plugin-react) and add `plugin:react/recommended` & `plugin:react/jsx-runtime` to the `extends` list