LangChain

https://docs.langchain.com
Admin
LangChain is a platform for agent engineering, offering open-source frameworks in Python and...
Tokens:6,015,827
Snippets:43,776
Trust Score:10
Update:1 day ago
Show doc for...
Tokens:
Raw
### Start port-forward to access UI

Source: https://docs.langchain.com/langsmith/self-hosted-mission-control

After installation, run this command to start a local port-forward. Then open http://localhost:3000 and log in with the credentials you provided during installation.

```bash
./install-script.sh forward
```

--------------------------------

### Install FastAPI for async web server example

Source: https://docs.langchain.com/oss/python/integrations/middleware/aws

Run this command to install FastAPI, which is required to run the asynchronous web server example that follows.

```bash
pip install -U fastapi
```

--------------------------------

### Install dependencies

Source: https://docs.langchain.com/langsmith/fleet/code

Run make setup to install dependencies via uv sync.

```bash
make setup    # installs dependencies via uv sync
```

--------------------------------

### Install dependencies for end-to-end example

Source: https://docs.langchain.com/oss/python/integrations/chat/anthropic

Install the required packages to run the end-to-end LangGraph example. This example requires langchain-openai and numpy.

```bash
pip install langchain-openai numpy
```

--------------------------------

### Install dependencies for Docugami loader example

Source: https://docs.langchain.com/oss/python/integrations/document_loaders/docugami

Installs the required packages: langchain-openai, tiktoken, langchain-chroma, and hnswlib. Run this command before executing the Python examples.

```bash
!poetry run pip install -U langchain-openai tiktoken langchain-chroma hnswlib
```

--------------------------------

### Docstring with minimal example and link to multimodal guide

Source: https://docs.langchain.com/oss/python/contributing/code

Include only one minimal example in docstrings, then link to comprehensive guides. This example shows a docstring with a minimal example and a link to the multimodal guide.

```python
"""
Example:
    ```python
    message = HumanMessage(content=[
        {"type": "image", "url": "https://example.com/image.jpg"}
    ])
    ```

See the [multimodal guide](https://docs.langchain.com/oss/integrations/chat/anthropic#multimodal)
for all supported input formats.
"""
```

--------------------------------

### Quick start: Start an HTTP server and get a service URL

Source: https://docs.langchain.com/langsmith/sandbox-service-urls

Start an HTTP server inside a sandbox and obtain a URL to access it. Use the SandboxClient to run a server, get a service handle, and make requests programmatically or open in a browser.

```python
from langsmith.sandbox import SandboxClient

client = SandboxClient()

with client.sandbox() as sb:
    handle = sb.run("python -m http.server 8000", timeout=0, wait=False)

    svc = sb.service(port=8000)

    # Open in a browser
    print(svc.browser_url)

    # Or make requests programmatically
    resp = svc.get("/")
    print(resp.status_code)

    handle.kill()
```

--------------------------------

### Local development setup commands

Source: https://docs.langchain.com/langsmith/deploy-nextjs

Commands to set up the local development environment: copy environment variables, install dependencies, and start the development server. Requires setting OPENAI_API_KEY in .env.local.

```bash
cp .env.example .env.local   # set OPENAI_API_KEY
pnpm install
pnpm dev
```

--------------------------------

### Example pip install output

Source: https://docs.langchain.com/oss/python/integrations/tools/tableau

Sample output showing that required packages are already satisfied after installing langchain-tableau.

```text
Requirement already satisfied: regex>=2022.1.18 in /Users/joe.constantino/.pyenv/versions/3.12.2/lib/python3.12/site-packages (from tiktoken<1,>=0.7->langchain-openai->langchain-tableau) (2024.11.6)
Requirement already satisfied: httpcore==1.* in /Users/joe.constantino/.pyenv/versions/3.12.2/lib/python3.12/site-packages (from httpx>=0.25.2->langgraph-sdk<0.2.0,>=0.1.42->langgraph->langchain-tableau) (1.0.7)
Requirement already satisfied: h11<0.15,>=0.13 in /Users/joe.constantino/.pyenv/versions/3.12.2/lib/python3.12/site-packages (from httpcore==1.*->httpx>=0.25.2->langgraph-sdk<0.2.0,>=0.1.42->langgraph->langchain-tableau) (0.14.0)
```

--------------------------------

### Install boto3 with uv

Source: https://docs.langchain.com/langsmith/mask-inputs-outputs

Install the boto3 library using uv. Required for the Amazon Comprehend example.

```bash
uv add boto3
```

--------------------------------

### Quickstart: List projects, traces, runs, datasets, experiments, threads, and sandboxes

Source: https://docs.langchain.com/langsmith/langsmith-cli

Core commands for listing LangSmith resources. Use these to explore projects, traces, runs, datasets, experiments, threads, and sandboxes.

```bash
# List tracing projects
langsmith project list

# List recent traces in a project
langsmith trace list --project my-app --limit 5

# Get a specific trace with full detail
langsmith trace get <trace-id> --project my-app --full

# List LLM runs with token counts
langsmith run list --project my-app --run-type llm --include-metadata

# Datasets and experiments
langsmith dataset list
langsmith experiment list --dataset my-eval-set

# Conversation threads
langsmith thread list --project my-chatbot

# Sandboxes
langsmith sandbox list
langsmith sandbox tunnel my-vm --remote-port 5432
```

--------------------------------

### Install LangSmith Tool Server and LangChain CLI

Source: https://docs.langchain.com/langsmith/fleet/mcp-framework

Install the required packages to get started with the LangSmith Tool Server.

```bash
pip install langsmith-tool-server
pip install langchain-cli-v2
```

--------------------------------

### Set up Python environment for LangSmith prompt quickstart

Source: https://docs.langchain.com/langsmith/prompt-engineering-quickstart

Creates a new directory, sets up a Python virtual environment, activates it, and installs required packages: langsmith, openai, and langchain_core.

```bash
mkdir ls-prompt-quickstart && cd ls-prompt-quickstart
python -m venv .venv
source .venv/bin/activate
pip install -qU langsmith openai langchain_core
```

--------------------------------

### 200 Response Example for GET Engine Picker Session

Source: https://docs.langchain.com/api-reference/integrations-v2/get-engine-picker-session-endpoint

Example JSON response for a successful request (HTTP 200). Contains an array of installs and a return_to URL.

```json
{
  "installs": [
    {
      "installation_id": 123,
      "account_login": "<string>",
      "account_type": "<string>",
      "already_in_org": false
    }
  ],
  "return_to": "<string>"
}
```

--------------------------------

### Install OpenWiki CLI and initialize documentation

Source: https://docs.langchain.com/oss/openwiki/overview

Install the OpenWiki CLI globally and initialize documentation for the current repository. This is the first step to generate a wiki for your codebase.

```bash
npm install -g openwiki
openwiki --init
```

--------------------------------

### GET /v2/auth/setup/{provider_id}

Source: https://docs.langchain.com/api-reference/auth-service-v2/oauth-setup-callback

Handles the OAuth setup callback redirect from GitHub Apps. This endpoint processes the "Setup URL" callback triggered when a user installs or updates their GitHub App installation. For update actions, it shows a success page; for new installations with code/state, it processes similar to the regular OAuth callback.

```APIDOC
## GET /v2/auth/setup/{provider_id}

### Description
Handle OAuth setup callback redirect from GitHub Apps.

This endpoint handles the “Setup URL” callback from GitHub Apps, which is triggered when a user installs or updates their GitHub App installation.

For “update” actions (user modified repo access via GitHub), we just show a success page since no token exchange is needed.

For new installations with code/state, we process similar to the regular OAuth callback.

### Method
GET

### Endpoint
/v2/auth/setup/{provider_id}

### Parameters

#### Path Parameters
- **provider_id** (string) - Required - The provider identifier.

#### Query Parameters
- **code** (string) - Optional - Authorization code from OAuth provider.
- **state** (string) - Optional - State parameter containing auth_id.
- **setup_action** (string) - Optional - Setup action from GitHub App.
- **installation_id** (integer) - Optional - GitHub App installation ID.
- **error** (string) - Optional - Error code from OAuth provider.
- **error_description** (string) - Optional - Error description from OAuth provider.

### Response

#### Success Response (200)
Successful Response

#### Error Response (422)
Validation Error

```json
{
  "detail": [
    {
      "loc": [
        "<string>"
      ],
      "msg": "<string>",
      "type": "<string>",
      "input": "<unknown>",
      "ctx": {}
    }
  ]
}
```
```

--------------------------------

### Install dependencies for Python evaluation quickstart

Source: https://docs.langchain.com/langsmith/evaluation-quickstart

Creates a new directory, sets up a Python virtual environment, and installs required packages: langsmith, openevals, and openai.

```bash
mkdir ls-evaluation-quickstart && cd ls-evaluation-quickstart
python -m venv .venv && source .venv/bin/activate
python -m pip install --upgrade pip
pip install -U langsmith openevals openai
```

--------------------------------

### Kill a running command in TypeScript

Source: https://docs.langchain.com/langsmith/sandbox-sdk

Use `handle.kill()` to terminate a running command. The example starts a sleep command, kills it, and awaits the result to get a non-zero exit code.

```typescript
const handle = await sandbox.run("sleep 300", { wait: false });
handle.kill();

const result = await handle.result;
console.log(result.exit_code); // non-zero
```

--------------------------------

### Install dependencies and run the development server with uv

Source: https://docs.langchain.com/langsmith/set-up-custom-auth

Add the local dependencies and start the LangGraph development server. The server will open Studio in your browser.

```bash
uv add .
langgraph dev
```

--------------------------------

### Instantiate client, assistant, and thread in Python

Source: https://docs.langchain.com/langsmith/reject-concurrent

Import required packages and create a client, assistant, and thread. Replace <DEPLOYMENT_URL> with your deployment URL.

```python
import httpx
from langchain_core.messages import convert_to_messages
from langgraph_sdk import get_client

client = get_client(url=<DEPLOYMENT_URL>)
# Using the graph deployed with the name "agent"
assistant_id = "agent"
thread = await client.threads.create()
```

--------------------------------

### Install dependencies for TypeScript evaluation quickstart

Source: https://docs.langchain.com/langsmith/evaluation-quickstart

Creates a new directory, initializes a Node.js project, installs required packages: langsmith, openevals, and openai, and initializes TypeScript configuration.

```bash
mkdir ls-evaluation-quickstart-ts && cd ls-evaluation-quickstart-ts
npm init -y
npm install langsmith openevals openai
npx tsc --init
```

--------------------------------

### Install required packages for RAG example

Source: https://docs.langchain.com/oss/python/integrations/embeddings/nvidia_ai_endpoints

Installs the necessary Python packages for the RAG retrieval example.

```bash
pip install -qU  langchain faiss-cpu tiktoken langchain-community
```

--------------------------------

### Store and search memories with PostgresStore

Source: https://docs.langchain.com/oss/javascript/langchain/long-term-memory

Use PostgresStore for persistent storage of long-term memories. It requires a PostgreSQL connection string and calling setup() before use. The example shows putting a memory, getting it by ID, and searching with a filter and query.

```typescript
import { PostgresStore } from "@langchain/langgraph-checkpoint-postgres/store";

const embed = (texts: string[]): number[][] => {
  return texts.map(() => [1.0, 2.0]);
};

const DB_URI =
  process.env.POSTGRES_URI ??
  "postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable";
const store = PostgresStore.fromConnString(DB_URI, {
  index: { embed, dims: 2 },
});
await store.setup();

const userId = "my-user";
const applicationContext = "chitchat";
const namespace = [userId, applicationContext];

await store.put(namespace, "a-memory", {
  rules: [
    "User likes short, direct language",
    "User only speaks English & TypeScript",
  ],
  "my-key": "my-value",
});

const item = await store.get(namespace, "a-memory");
const items = await store.search(namespace, {
  filter: { "my-key": "my-value" },
  query: "language preferences",
});
```

--------------------------------

### Quickstart: create_agent with automatic tracing

Source: https://docs.langchain.com/oss/python/langchain/observability

Run a LangChain agent with create_agent; all steps are traced automatically to the default LangSmith project.

```python
from langchain.agents import create_agent


def send_email(to: str, subject: str, body: str):
    """Send an email to a recipient."""
    # ... email sending logic
    return f"Email sent to {to}"

def search_web(query: str):
    """Search the web for information."""
    # ... web search logic
    return f"Search results for: {query}"

agent = create_agent(
    model="gpt-5.5",
    tools=[send_email, search_web],
    system_prompt="You are a helpful assistant that can send emails and search the web."
)

# Run the agent - all steps will be traced automatically
response = agent.invoke({
    "messages": [{"role": "user", "content": "Search for the latest AI news and email a summary to john@example.com"}]
})
```

--------------------------------

### Go example for POST /v2/integrations/github/installation-link

Source: https://docs.langchain.com/api-reference/integrations-v2/get-github-install-link-endpoint

Use the net/http package to send a POST request and print the response body.

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.example.com/v2/integrations/github/installation-link"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Install langchain-text-splitters

Source: https://docs.langchain.com/oss/python/integrations/chat/anthropic

Install the langchain-text-splitters package required for the example.

```bash
pip install langchain-text-splitters
```

--------------------------------

### Create a sandbox and run a command inside it

Source: https://docs.langchain.com/langsmith/sandbox-cli

Create a sandbox named my-vm, then run a command inside it. The create command boots the sandbox and returns once it reports ready, so the next command can run straight away. There is no separate wait step.

```bash
langsmith sandbox create my-vm

langsmith sandbox exec my-vm -- python --version
```

--------------------------------

### Install langchain-elasticsearch and start Elasticsearch locally

Source: https://docs.langchain.com/oss/python/integrations/vectorstores

Install the langchain-elasticsearch package and start Elasticsearch locally using the start-local script. This sets up Elasticsearch for use with LangChain.

```bash
pip install -qU langchain-elasticsearch
curl -fsSL https://elastic.co/start-local | sh
```

--------------------------------

### Example files

Source: https://docs.langchain.com/oss/javascript/integrations/document_loaders/file_loaders/multi_file

Example files

```text
src/document_loaders/example_data/example/
├── example.txt
└── example.csv

src/document_loaders/example_data/example2/
├── example.json
└── example.jsonl
```

--------------------------------

### JavaScript example for GET /assistants/{assistant_id}/graph

Source: https://docs.langchain.com/langsmith/agent-server-api/assistants/get-assistant-graph

Use this JavaScript fetch example to get the assistant graph. Replace {assistant_id} with the actual assistant UUID.

```javascript
const options = {method: 'GET'};

fetch('https://api.example.com/assistants/{assistant_id}/graph', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));
```

--------------------------------

### Install project dependencies

Source: https://docs.langchain.com/oss/javascript/contributing/documentation

Run make install to install the necessary dependencies for the documentation project.

```bash
make install
```

--------------------------------

### Common setup for trajectory match examples

Source: https://docs.langchain.com/oss/python/langchain/test/evals

Defines a get_weather tool and creates an agent with that tool. This setup is used by the strict and unordered trajectory match examples.

```python
from langchain.agents import create_agent
from langchain.tools import tool
from langchain.messages import HumanMessage, AIMessage, ToolMessage
from agentevals.trajectory.match import create_trajectory_match_evaluator


@tool
def get_weather(city: str):
    """Get weather information for a city."""
    return f"It's 75 degrees and sunny in {city}."

agent = create_agent("claude-sonnet-4-6", tools=[get_weather])
```

--------------------------------

### Install sandbox extras with dcode --install

Source: https://docs.langchain.com/oss/deepagents/code/cli-reference

Install sandbox extras with dcode --install. For example, dcode --install daytona or dcode --install all-sandboxes.

```bash
dcode --install daytona
```

```bash
dcode --install all-sandboxes
```

--------------------------------

### Create environment file

Source: https://docs.langchain.com/langsmith/deploy-vite-langsmith

Copy the example environment file to create a local .env file for configuration.

```bash
cp .env.example .env
```

--------------------------------

### JavaScript example for getting thread state at checkpoint

Source: https://docs.langchain.com/langsmith/agent-server-api/threads/get-thread-state-at-checkpoint

Use this JavaScript fetch example to get the thread state at a checkpoint. Replace {thread_id} and {checkpoint_id} with actual values.

```javascript
const options = {method: 'GET'};

fetch('https://api.example.com/threads/{thread_id}/state/{checkpoint_id}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));
```

--------------------------------

### Set up TypeScript environment for LangSmith prompt quickstart

Source: https://docs.langchain.com/langsmith/prompt-engineering-quickstart

Creates a new directory, initializes a Node.js project, installs langsmith, openai, typescript, and ts-node, and initializes a TypeScript configuration file.

```bash
mkdir ls-prompt-quickstart-ts && cd ls-prompt-quickstart-ts
npm init -y
npm install langsmith openai typescript ts-node
npx tsc --init
```

--------------------------------

### Install matplotlib and scikit-learn

Source: https://docs.langchain.com/oss/python/integrations/embeddings/google_generative_ai

Install the required packages for the embedding similarity example.

```bash
pip install -qU matplotlib scikit-learn
```

--------------------------------

### Install langchain-oci and oracle-ads with uv

Source: https://docs.langchain.com/oss/python/integrations/chat/oci_data_science

Install the required packages using uv.

```bash
uv add langchain-oci oracle-ads
```

--------------------------------

### Use Tavily Research and Get Research tools within a LangChain agent

Source: https://docs.langchain.com/oss/javascript/integrations/tools/tavily_get_research

Pass both TavilyResearch and TavilyGetResearch tools to createAgent so the agent can start a research task and retrieve results by request ID. The example streams events and prints tokens and tool calls.

```javascript
import { ChatOpenAI } from "@langchain/openai";
import { TavilyGetResearch, TavilyResearch } from "@langchain/tavily";
import { createAgent } from "langchain";

const llm = new ChatOpenAI({
  model: "gpt-5.5",
});

const agent = createAgent({
  model: llm,
  tools: [
    new TavilyResearch({
      model: "mini",
    }),
    new TavilyGetResearch(),
  ],
});

const userInput =
  "Start a research task on AI agents, then retrieve the results when ready.";

const stream = await agent.streamEvents(
  { messages: [{ role: "user", content: userInput }] },
  { version: "v3" },
);

await Promise.all([
  (async () => {
    for await (const message of stream.messages) {
      for await (const token of message.text) {
        process.stdout.write(token);
      }
    }
  })(),
  (async () => {
    for await (const call of stream.toolCalls) {
      console.dir({ name: call.name, input: call.input }, { depth: null });
      await call.output;
    }
  })(),
]);

await stream.output;
```

--------------------------------

### Start workspace manager with openwiki link

Source: https://docs.langchain.com/oss/openwiki/search-and-link

Start the workspace manager from a directory that contains the repositories, for example `~/dev`. Create a workspace such as `Payments`, then select the repositories to include.

```bash
cd ~/dev
openwiki link
```

--------------------------------

### cURL GET request to OAuth setup callback

Source: https://docs.langchain.com/api-reference/auth-service-v2/oauth-setup-callback

Use this cURL command to send a GET request to the OAuth setup callback endpoint. Replace {provider_id} with the actual provider identifier.

```bash
curl --request GET \
  --url https://api.example.com/v2/auth/setup/{provider_id}
```
Tokens:
Raw