Docs by LangChain

Docs

• Authenticate: Get OAuth token or start authentication flow if needed.
• Check Oauth Token Exists: Return whether the current user has any tokens for a given provider (across agents).
• Check Workspace Slack Tokens Exist: Check if the workspace has any Slack tokens.
• Create Mcp Oauth Provider: Create an OAuth provider via MCP auto-discovery.
• Create Oauth Provider: Create a new OAuth provider manually.
• Delete Oauth Provider: Delete an OAuth provider.
• Delete Oauth Tokens For User: Delete all tokens for the current user for the given provider (across agents).
• Get Oauth Provider: Get a specific OAuth provider.
• List Oauth Providers: List OAuth providers.
• Oauth Callback
• Oauth Callback Get: Handle OAuth callback redirect from OAuth providers.

Processes the OAuth token exchange, then redirects to the frontend callback page for a consistent UI experience.

• Oauth Setup Callback: 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.

• Revoke All Slack Tokens For Workspace: Revoke ALL Slack tokens for the workspace. Admin-only action that disconnects Slack entirely.

This is a destructive operation that:

• Revokes all Slack tokens on Slack's side for all users in the workspace
• Deletes all Slack tokens from the database
• Update Oauth Provider: Update an OAuth provider.
• Wait For Auth Completion: Wait for OAuth authentication completion.
• Create Deployment: Create a new deployment.
• Delete Deployment: Delete a deployment by ID.
• Delete Deployments: Delete multiple deployments with partial success support.

Returns: - 200: All deployments deleted successfully - 207: Some deployments deleted successfully, some failed

• Get Deployment: Get a deployment by ID.
• Get Revision: Get a revision by ID for a deployment.
• List Deployments: List all deployments.
• List Revisions: List all revisions for a deployment.
• Patch Deployment: Patch a deployment by ID.
• Redeploy Revision: Redeploy a specific revision ID.
• List GitHub Integrations: List available GitHub integrations for LangGraph Platfom Cloud SaaS.
• List GitHub Repositories: List available GitHub repositories for an integration that are available to deploy to LangSmith Deployment.
• Create Listener: Create a listener.
  

Creating a listener is only allowed for LangSmith organizations with self-hosted enterprise plans. - [Delete Listener](https://docs.langchain.com/api-reference/listeners-v2/delete-listener.md): Delete a listener by ID. - [Get Listener](https://docs.langchain.com/api-reference/listeners-v2/get-listener.md): Get a listener by ID. - [List Listeners](https://docs.langchain.com/api-reference/listeners-v2/list-listeners.md): List all listeners. - [Patch Listener](https://docs.langchain.com/api-reference/listeners-v2/patch-listener.md): Patch a listener by ID. - [Create a Sandbox](https://docs.langchain.com/api-reference/sandboxes-v2/create-a-sandbox.md): Create a new SandboxClaim in tenant's namespace.

If wait_for_ready is True (default), this will block until the sandbox is ready or the timeout is reached.

The sandbox creation can fail for several reasons:

• Image pull errors (invalid image, registry auth issues)
• Container crashes (bad entrypoint, missing dependencies, health check failures)
• Scheduling failures (no suitable nodes available)

Sandbox creation is subject to quota limits (count, CPU, memory) configured via Metronome org config.

On failure, the claim is automatically cleaned up and a descriptive error is returned.

• Create a Sandbox Pool: Create a new Sandbox Pool in tenant's namespace.

Pools pre-provision sandboxes from a template for faster claim binding.

Requirements:

• The referenced template must exist
• The template must not have any volume mounts (volumes are stateful)

Pool creation is subject to quota limits. The total resource usage (replicas * per-replica resources) is checked against the organization's quota limits.

• Create a SandboxTemplate: Create a new SandboxTemplate in tenant's namespace.
• Create a Volume: Create a new persistent volume in the tenant's sandbox namespace.

This creates both a PersistentVolume (PV) and PersistentVolumeClaim (PVC). The volume can then be referenced in sandbox templates.

Volume creation is subject to quota limits (count and total storage) configured via Metronome org config.

If wait_for_ready is True (default), this blocks until the PVC is bound or the timeout is reached.

• Delete a Registry: Delete a private container registry.

This will fail if any templates reference this registry. Delete or update those templates first before deleting the registry.

• Delete a Sandbox: Delete a SandboxClaim from tenant's namespace.
• Delete a Sandbox Pool: Delete a Sandbox Pool from tenant's namespace.

This will terminate all sandboxes in the pool.

• Delete a SandboxTemplate: Delete a SandboxTemplate from tenant's namespace.

Deletion will fail if the template is in use by any sandboxes or pools.

• Delete a Volume: Delete a persistent volume (both PV and PVC) from tenant's namespace.

This will fail if any templates reference this volume. Delete or update those templates first before deleting the volume.

• Get a Registry: Get a specific registry by name.

Returns metadata only -- credentials are never included in responses.

• Get a Sandbox: Get a specific Sandbox by name in tenant's namespace.

This endpoint queries the database for fast performance.

• Get a Sandbox Pool: Get a specific Sandbox Pool by name in tenant's namespace.

This endpoint queries the database for fast performance.

• Get a SandboxTemplate: Get a specific SandboxTemplate by name in tenant's namespace.

This endpoint queries the database for fast performance.

• Get a Volume: Get a specific volume by name in the tenant's sandbox namespace.

This endpoint queries the database for fast performance.

• Get sandbox resource usage and quota limits: Return current resource consumption and organisation quota limits.

Sandbox counts include both direct claims and warmpool replicas. For self-hosted deployments limit fields are 0 (quotas not enforced).

• Get Sandbox Status: Lightweight endpoint for polling sandbox provisioning status.

Returns only status and status_message -- no template resolution or full claim data. Designed for high-frequency polling by SDKs.

• List all Registries: List all registered private container registries for the tenant.

Returns metadata only -- credentials are never included in responses. Supports optional pagination via limit and offset query parameters.

• List all Sandbox Pools: List all Sandbox Pools in the tenant's namespace.

This endpoint queries the database for fast performance. Supports optional pagination via limit and offset query parameters.

• List all Sandboxes: List all Sandboxes in the tenant's namespace.

This endpoint queries the database for fast performance. Supports optional pagination via limit and offset query parameters.

• List all SandboxTemplates: List all SandboxTemplates in the tenant's sandbox namespace.

This endpoint queries the database for fast performance. Supports optional pagination via limit and offset query parameters.

• List all Volumes: List all persistent volumes in the tenant's sandbox namespace.

This endpoint queries the database for fast performance. Supports optional pagination via limit and offset query parameters.

• Register a Private Container Registry: Register a private container registry for pulling sandbox images.

Provide the registry URL, username, and password (or access token). The backend builds the K8s dockerconfigjson secret internally.

The registry can then be referenced in sandbox templates via the registry_name field to pull images from private registries.

• Update a Registry: Update a registry's display name and/or credentials.

You can update:

• name: New display name (must be unique within the organization)
• url, username, password: New credentials (all three must be provided together)
• Update a Sandbox: Update a Sandbox's display name.

Currently only the display name can be updated.

• Update a Sandbox Pool: Update a Sandbox Pool's display name and/or replica count.

You can update:

• name: New display name (must be unique within the organization)
• replicas: New replica count (scaling up is subject to quota limits)

The template reference cannot be changed after creation. Set replicas to 0 to pause the pool without deleting it.

• Update a SandboxTemplate: Update a SandboxTemplate's display name.

Currently only the display name can be updated. The image, resources, and volume mounts cannot be changed after creation.

• Update a Volume: Update a volume's display name and/or storage size.

You can update:

• name: New display name (must be unique within the organization)
• size: New storage size (only increases allowed, cannot decrease)

The storage increase is subject to quota limits configured via Metronome org config.

• null
• Attribute-based access control
• Connect an authentication provider
• Human-in-the-loop using server API
• Add metadata and tags to traces
• Overview
• Set up Agent Auth (Beta): Enable secure access from agents to any system using OAuth 2.0 credentials with Agent Auth.
• LangSmith Agent Builder: Create helpful AI agents without code. Start from a template, connect your accounts, and let the agent handle routine work while you stay in control.
• Auth-aware tool responses: Format tool responses to trigger OAuth flows and resume execution automatically.
• Call agents from code: Invoke Agent Builder agents from Python, JavaScript, or any language through the REST API.
• Essentials: Agent Builder's core features
• Manage agent settings: Manage your agents in Agent Builder.
• LangSmith Tool Server
• Pricing FAQ
• Quickstart: Build an agent from a template
• Remote MCP servers: Connect Agent Builder to popular remote MCP servers
• Manage Agent Builder
• Workspace setup: Add required workspace secrets for models and tools used by Agent Builder.
• Integrate Slack with an agent: Connect the LangSmith Agent Builder to your Slack workspace to let your agents communicate with users in Slack.
• Templates: Start faster with curated Agent Builder templates and customize tools, prompts, and triggers.
• Tool integrations: Give your agents access to a wide range of tools and services.
• Triggers: Configure triggers to start your Agent Builder agents automatically.
• Agent Builder webhooks: Integrate agent publishing with external systems, CI/CD pipelines, or custom deployment workflows.
• Agent Server
• A2A JSON-RPC: Communicate with an assistant using the Agent-to-Agent (A2A) Protocol over JSON-RPC 2.0. This endpoint accepts a JSON-RPC envelope and dispatches based on method.

Supported Methods:

• message/send: Send a message and wait for the final Task result.
• message/stream: Send a message and receive Server-Sent Events (SSE) JSON-RPC responses.
• tasks/get: Fetch the current state of a Task by ID.
• tasks/cancel: Request cancellation (currently not supported; returns an error).

LangGraph Mapping:

• message.contextId maps to LangGraph thread_id.

Notes:

• Only text and data parts are supported; file parts are not.

• If message.contextId is omitted, a new context is created.

• Text parts require the assistant input schema to include a messages field.

• Count Assistants: Get the count of assistants matching the specified criteria.

• Create Assistant: Create an assistant.

An initial version of the assistant will be created and the assistant is set to that version. To change versions, use the POST /assistants/{assistant_id}/latest endpoint.

• Delete Assistant: Delete an assistant by ID.

All versions of the assistant will be deleted as well.

• Get Assistant: Get an assistant by ID.
• Get Assistant Graph: Get an assistant by ID.
• Get Assistant Schemas: Get an assistant by ID.
• Get Assistant Subgraphs: Get an assistant's subgraphs.
• Get Assistant Subgraphs by Namespace: Get an assistant's subgraphs filtered by namespace.
• Get Assistant Versions: Get all versions of an assistant.
• Patch Assistant: Update an assistant.
• Search Assistants: Search for assistants.

This endpoint also functions as the endpoint to list all assistants.

• Set Latest Assistant Version: Set the latest version for an assistant.

• Count Crons: Get the count of crons matching the specified criteria.

• Create Cron: Create a cron to schedule runs on new threads.

• Create Thread Cron: Create a cron to schedule runs on a thread.

• Delete Cron: Delete a cron by ID.

• Search Crons: Search all active crons

• Update Cron: Update a cron job by ID.

• MCP Get: Implemented according to the Streamable HTTP Transport specification.

• MCP Post: Implemented according to the Streamable HTTP Transport specification. Sends a JSON-RPC 2.0 message to the server.

• Request: Provide an object with jsonrpc, id, method, and optional params.

• Response: Returns a JSON-RPC response or acknowledgment.

Notes:

• Stateless: Sessions are not persisted across requests.

• Terminate Session: Implemented according to the Streamable HTTP Transport specification. Terminate an MCP session. The server implementation is stateless, so this is a no-op.

• Create Background Run: Create a run and return the run ID immediately. Don't wait for the final run output.

• Create Run Batch: Create a batch of runs and return immediately.

• Create Run, Stream Output: Create a run and stream the output.

• Create Run, Wait for Output: Create a run, wait for the final output and then return it.

• Delete an item.

• List namespaces with optional match conditions.

• Retrieve a single item.

• Search or list items within a namespace prefix.: Lists items ordered by last updated time. If a query is provided, performs a natural language search instead. Supports pagination via limit and offset, and filtering via filter.

• Store or update an item.

• API Documentation: A local reference to the Agent Server API documentation.

• Health Check: Check the health status of the server. Optionally check database connectivity.

• Server Information: Get server version information, feature flags, and metadata.

• System Metrics: Get system metrics in Prometheus or JSON format for monitoring and observability.

• Cancel Run

• Cancel Runs: Cancel one or more runs. Can cancel runs by thread ID and run IDs, or by status filter.

• Create Background Run: Create a run in existing thread, return the run ID immediately. Don't wait for the final run output.

• Create Run, Stream Output: Create a run in existing thread. Stream the output.

• Create Run, Wait for Output: Create a run in existing thread. Wait for the final output and then return it.

• Delete Run: Delete a run by ID.

• Get Run: Get a run by ID.

• Join Run: Wait for a run to finish.

• Join Run Stream: Join a run stream. This endpoint streams output in real-time from a run similar to the /threads/THREAD_ID/runs/stream endpoint. If the run has been created with stream_resumable=true, the stream can be resumed from the last seen event ID.

• List Runs: List runs for a thread.

• Copy Thread: Create a new thread with a copy of the state and checkpoints from an existing thread.

• Count Threads: Get the count of threads matching the specified criteria.

• Create Thread: Create a thread.

• Delete Thread: Delete a thread by ID.

• Get Thread: Get a thread by ID.

• Get Thread History: Get all past states for a thread.

• Get Thread History Post: Get all past states for a thread.

• Get Thread State: Get state for a thread.

The latest state of the thread (i.e. latest checkpoint) is returned.

• Get Thread State At Checkpoint: Get state for a thread at a specific checkpoint.
• Get Thread State At Checkpoint: Get state for a thread at a specific checkpoint.
• Join Thread Stream: This endpoint streams output in real-time from a thread. The stream will include the output of each run executed sequentially on the thread and will remain open indefinitely. It is the responsibility of the calling client to close the connection.
• Patch Thread: Update a thread.
• Prune Threads: Prune threads by ID. The 'delete' strategy removes threads entirely. The 'keep_latest' strategy prunes old checkpoints but keeps threads and their latest state.
• Search Threads: Search for threads.

This endpoint also functions as the endpoint to list all threads.

• Update Thread State: Add state to a thread.
• Agent Server changelog
• Distributed tracing with Agent Server: Unify traces when calling your deployed Agent Server from another service using RemoteGraph or the SDK.
• How to collect user feedback for Agent Server runs
• Configure LangSmith Agent Server for scale
• Alerts in LangSmith
• Configure webhook notifications for LangSmith alerts
• Analyze an experiment
• Custom instrumentation
• Annotate traces and runs inline
• Use annotation queues
• Manage feedback & annotation queues programmatically
• Control plane API reference for LangSmith Deployment
• App development in LangSmith Deployment
• Application structure
• Assistants
• Log user feedback using the SDK
• How to audit evaluator scores
• Authentication & access control
• Authentication methods
• Self-hosted LangSmith on AWS
• Self-hosted LangSmith on Azure
• How to kick off background runs
• Manage billing in your account
• Automatically run evaluators on experiments
• Implement a CI/CD pipeline using LangSmith Deployment and Evaluation
• LangGraph CLI
• Cloud
• How to define a code evaluator
• How to define a code evaluator
• How to compare experiment results
• Compare traces
• LangSmith Deployment components
• How to create a composite evaluator
• How to create a composite evaluator
• Conditional tracing
• Use HTTP headers for runtime configuration
• Include HTTP headers in server logs
• Manage assistants
• Configure run input and output preview
• How to add TTLs to your application
• LangSmith control plane
• Cost tracking
• Create a prompt
• Create an account and API key
• How to improve your evaluator with few-shot examples
• Use cron jobs
• Add custom authentication
• How to use a custom checkpointer: Replace the built-in Postgres checkpointer with a custom BaseCheckpointSaver implementation in your agent deployment.
• How to customize the Dockerfile
• Connect to a custom model
• How to add custom lifespan events
• How to add custom middleware
• Connect to an OpenAI compliant model provider/proxy
• Custom output rendering
• How to add custom routes
• How to use a custom store: Replace the built-in Postgres store with a custom BaseStore implementation in your agent deployment.
• Monitor projects with dashboards
• Bulk exporting trace data
• LangSmith data plane
• Data purging for compliance
• Data storage and privacy
• Dataset prebuilt JSON schema types
• Dataset transformations
• How to define a target function to evaluate
• Set up hybrid LangSmith
• Deploy other frameworks
• Enable LangSmith Deployment
• Self-host standalone servers
• Deploy on Cloud
• Deploy with control plane
• Deploy your app to Cloud
• LangSmith Deployment: Deploy and manage agents with durable execution, real-time streaming, and horizontal scaling.
• Troubleshooting for self-hosted deployments
• Implement distributed tracing
• Self-host LangSmith with Docker
• Double texting
• Add encryption at-rest
• Enqueue concurrent
• Environment variables
• Evaluate a chatbot
• Evaluate a complex agent
• How to add evaluators to an existing experiment (Python only)
• How to evaluate a graph
• How to evaluate an LLM application
• How to evaluate an application's intermediate steps
• How to run a pairwise evaluation
• Evaluate a RAG application
• Run an evaluation with multimodal content
• How to evaluate with OpenTelemetry
• How to retry failed runs in experiments (Python only)
• LangSmith Evaluation
• Application-specific evaluation approaches
• How to run an evaluation asynchronously
• Evaluation concepts
• Evaluation quickstart
• Evaluation types
• Example data format
• Experiment configuration
• Export LangSmith telemetry to your observability backend
• Query traces (SDK)
• Frequently asked questions
• Feedback data format
• How to fetch performance metrics for an experiment
• How to filter experiments in the UI
• Filter traces
• Self-hosted LangSmith on GCP
• How to implement generative user interfaces with LangGraph
• Integrations
• Granular billable usage: Retrieve detailed trace usage data broken down by workspace, project, user, or API key.
• Rebuild graph at runtime: Rebuild your graph with different configurations for each run using ServerRuntime.
• LangSmith docs
• Time travel using the server API
• Hybrid
• Improve LLM-as-judge evaluators using human feedback
• Discover errors and usage patterns with the Insights Agent
• Enable Insights
• Integrations
• Interrupt concurrent
• Manage user access in SSO organizations
• Self-host LangSmith on Kubernetes
• How to evaluate a runnable
• LangGraph JS/TS SDK
• LangGraph Python SDK
• Configure your collector for LangSmith telemetry
• LangSmith Fetch
• LangSmith-managed ClickHouse
• LangSmith MCP Server: Use the Model Context Protocol (MCP) server to let language models fetch conversation history, prompts, runs, datasets, experiments, and billing from LangSmith.
• How to define an LLM-as-a-judge evaluator
• How to define an LLM-as-a-judge evaluator
• How to run an evaluation locally (Python only)
• Local development & testing
• Run a LangGraph app locally
• Log LLM calls
• Log multimodal traces
• Log retriever traces
• Log traces to a specific project
• Metadata parameters reference
• Manage datasets
• Create and manage datasets in the UI
• How to create and manage datasets programmatically
• Manage your organization using the API
• Manage prompts
• Manage prompts programmatically
• Configure prompt settings
• Prevent logging of sensitive data in traces
• How to return categorical vs numerical metrics
• Monorepo support
• How to simulate multi-turn interactions
• Include multimodal content in a prompt
• Test multi-turn conversations
• How to return multiple scores in one evaluator
• Troubleshoot trace nesting
• LangSmith Observability
• Observability concepts
• Trace an LLM application tutorial
• Tracing quickstart
• Deploy an observability stack for your LangSmith deployment
• Observability in Studio
• Set up online code evaluators
• Set up composite online evaluators
• Set up LLM-as-a-judge online evaluators
• Set up multi-turn online evaluators
• Document API authentication in OpenAPI
• Optimize a classifier
• Organization and workspace operations reference
• View server logs for a trace
• Set up LangSmith
• Model providers
• LangSmith Polly
• LangSmith Polly
• LangSmith Polly
• LangSmith Polly
• How to use prebuilt evaluators
• Frequently Asked Questions
• Pricing plans
• How to sync prompts with GitHub
• Prompt engineering
• Prompt engineering concepts
• Prompt engineering quickstart
• Prompt template format guide
• How to run evaluations with pytest
• Get started with Studio
• How to handle model rate limits
• Role-based access control
• How to read experiment results locally
• LangSmith reference
• Regions FAQ
• Reject Concurrent
• Release versions
• RemoteGraph
• How to evaluate with repetitions
• Make conversations private
• Rollback Concurrent
• Set up automation rules
• Run backtests on a new version of an agent
• Run (span) data format
• How to use the REST API
• Run an evaluation from the prompt playground
• How to run multiple agents on the same thread
• Set a sampling rate for traces
• Scalability & resilience
• Delete workspaces
• Delete organizations
• Delete traces
• Generate ClickHouse stats
• Generate query stats
• Run support queries against ClickHouse
• Run support queries against PostgreSQL
• Basic authentication with email and password
• Enable blob storage
• Configure custom TLS certificates
• Egress for billing and operational telemetry
• Connect to an external ClickHouse database
• Connect to an external PostgreSQL database
• Connect to an external Redis database
• Create an Ingress for installations (Kubernetes)
• Mirror images for your LangSmith installation
• View trace counts across your organization
• Use environment variables for model providers
• Configure LangSmith for scale
• Set up SSO with OAuth2.0 and OIDC
• Enable TTL and data retention
• Upgrade an installation
• Interact with your self-hosted instance of LangSmith
• Customize user management
• Use an existing secret for your installation (Kubernetes)
• Self-hosted LangSmith
• Self-hosted LangSmith changelog
• How to add semantic search to your agent deployment
• A2A endpoint in Agent Server
• Agent Server API reference for LangSmith Deployment
• MCP endpoint in Agent Server
• Trace JS functions in serverless environments
• Set up custom authentication
• Set up feedback criteria
• Set up hierarchy
• Set up resource tags
• How to set up an application with requirements.txt
• How to set up a JavaScript application
• How to set up an application with pyproject.toml
• Share or unshare a trace publicly
• LangSmith API reference
• LangSmith Deployment SDK
• LangSmith JS/TS SDK
• LangSmith Python SDK
• Stateless runs
• LangSmith status
• Streaming API
• LangSmith Studio
• How to define a summary evaluator
• Test a ReAct agent with Pytest/Vitest and LangSmith
• Configure threads
• Trace Anthropic applications
• Trace Amazon Bedrock applications
• Trace Claude Agent SDK applications
• Trace Claude Code applications
• Trace Deep Agents applications
• Trace DeepSeek applications
• Trace generator functions
• Trace OpenAI applications
• Trace query syntax
• Trace with API
• Trace AutoGen applications
• Trace CrewAI applications
• Trace Google ADK applications
• Trace Google Gemini applications
• Trace Instructor applications
• Trace LangChain applications (Python and JS/TS)
• Trace LangGraph applications
• Trace LiveKit applications
• Trace Mastra applications
• Trace Microsoft Agent Framework applications
• Trace Mistral applications
• Trace OpenAI Agents SDK applications
• Trace with OpenTelemetry
• Trace Pipecat applications
• Trace PydanticAI applications
• Trace Semantic Kernel applications
• Trace with Temporal: Learn how to trace Temporal workflows and activities in LangSmith using OpenTelemetry.
• Trace Vercel AI SDK applications (JS/TS only)
• Trace without setting environment variables
• How to evaluate your agent with trajectory evaluations
• Troubleshooting
• Studio troubleshooting
• Troubleshoot variable caching
• How to upload experiments run outside of LangSmith with the REST API
• Upload files with traces
• How to interact with a deployment using RemoteGraph
• How to use Studio
• Use threads
• Use tools in a prompt
• Use webhooks
• User management
• How to run evaluations with Vitest/Jest
• Configure webhook notifications for rules
• Workload isolation
• Write your prompt with AI
• Errors
• Context overview
• Memory overview
• Frameworks, runtimes, and harnesses: Understand the differences between LangChain, LangGraph, and Deep Agents and when to use each one
• Contributing to code
• Co-marketing
• Contributing to documentation
• Implement a LangChain integration
• Contributing integrations
• Contributing
• Publish an integration
• Using standard tests
• Backends: Choose and configure filesystem backends for deep agents. You can specify routes to different backends, implement virtual filesystems, and enforce policies.
• Deep Agents CLI: Terminal coding agent built on the Deep Agents SDK
• Custom model providers: Configure any LangChain-compatible model provider for the Deep Agents CLI
• Comparison with OpenCode and Claude Agent SDK: Compare LangChain Deep Agents with OpenCode and Claude Agent SDK to choose the right tool for your use case
• Customize Deep Agents: Learn how to customize deep agents with system prompts, tools, subagents, and more
• Harness capabilities
• Human-in-the-loop: Learn how to configure human approval for sensitive tool operations
• Long-term memory: Learn how to extend deep agents with persistent memory across threads
• Deep Agents overview: Build agents that can plan, use subagents, and leverage file systems for complex tasks
• Quickstart: Build your first deep agent in minutes
• Sandboxes: Execute code in isolated environments with sandbox backends
• Skills: Learn how to extend your deep agent's capabilities with skills
• Frontend: Build React UIs that display real-time subagent streams from deep agents
• Overview: Stream real-time updates from deep agent runs and subagent execution
• Subagents: Learn how to use subagents to delegate work and keep context clean
• Callback integrations: Integrate with callbacks using LangChain JavaScript.
• ChatAnthropic integration: Integrate with the ChatAnthropic chat model using LangChain JavaScript.
• AzureChatOpenAI integration: Integrate with the AzureChatOpenAI chat model using LangChain JavaScript.
• BedrockChat integration: Integrate with the BedrockChat chat model using LangChain JavaScript.
• ChatGoogle integration: Integrate with the ChatGoogle chat model using LangChain JavaScript.
• ChatGoogleGenerativeAI integration: Integrate with the ChatGoogleGenerativeAI chat model using LangChain JavaScript.
• ChatVertexAI integration: Integrate with the ChatVertexAI chat model using LangChain JavaScript.
• Chat model integrations: Integrate with chat models using LangChain JavaScript.
• ChatOpenAI integration: Integrate with the ChatOpenAI chat model using LangChain JavaScript.
• Document loader integrations: Integrate with document loaders using LangChain JavaScript.
• Document transformer integrations: Integrate with document transformers using LangChain JavaScript.
• Cache integrations: Integrate with caches using LangChain JavaScript.
• LLM integrations: Integrate with LLMs using LangChain JavaScript.
• Middleware integrations: Integrate with middleware using LangChain JavaScript.
• All LangChain JavaScript integration providers
• Anthropic integrations: Integrate with Anthropic using LangChain JavaScript.
• AWS integrations: Integrate with AWS using LangChain JavaScript.
• Google integrations: Integrate with Google using LangChain JavaScript.
• Microsoft integrations: Integrate with Microsoft using LangChain JavaScript.
• OpenAI integrations: Integrate with OpenAI using LangChain JavaScript.
• LangChain JavaScript integrations: Integrate with providers using LangChain JavaScript/TypeScript.
• Retriever integrations: Integrate with retrievers using LangChain JavaScript.
• Text splitter integrations: Integrate with text splitters using LangChain.
• Store integrations: Integrate with stores using LangChain JavaScript.
• AzureOpenAIEmbeddings integration: Integrate with the AzureOpenAIEmbeddings embedding model using LangChain JavaScript.
• BedrockEmbeddings integration: Integrate with the BedrockEmbeddings embedding model using LangChain JavaScript.
• Embedding model integrations: Integrate with embedding models using LangChain JavaScript.
• OpenAIEmbeddings integration: Integrate with the OpenAIEmbeddings embedding model using LangChain JavaScript.
• Anthropic integration: Integrate with the Anthropic tool using LangChain JavaScript.
• Google integration: Integrate with Google Gemini tools using LangChain JavaScript.
• Tool integrations: Integrate with tools using LangChain JavaScript.
• OpenAI integration: Integrate with the OpenAI tool using LangChain JavaScript.
• Vector store integrations: Integrate with vector stores using LangChain JavaScript.
• LangChain Academy
• Agents
• Changelog
• Component architecture
• Context engineering in agents
• LangSmith Deployment
• Get help
• Guardrails: Implement safety checks and content filtering for your agents
• Human-in-the-loop
• Install LangChain
• Build a semantic search engine with LangChain
• Long-term memory
• Model Context Protocol (MCP)
• Messages
• Prebuilt middleware: Prebuilt middleware for common agent use cases
• Custom middleware
• Overview: Control and customize agent execution at every step
• Models
• Custom workflow
• Handoffs
• Build customer support with handoffs
• Multi-agent
• Router
• Build a multi-source knowledge base with routing
• Skills
• Build a SQL assistant with on-demand skills
• Subagents
• Build a personal assistant with subagents
• LangSmith Observability
• LangChain overview: LangChain is an open source framework with a pre-built agent architecture and integrations for any model or tool — so you can build agents that adapt as fast as the ecosystem evolves
• Philosophy: LangChain exists to be the easiest place to start building with LLMs, while also being flexible and production-ready.
• Quickstart
• Build a RAG agent with LangChain
• Retrieval
• Runtime
• Short-term memory
• Build a SQL agent
• Frontend: Build generative UIs with real-time streaming from LangChain agents, LangGraph graphs, and custom APIs
• Overview: Stream real-time updates from agent runs
• Structured output
• LangSmith Studio
• Test
• Tools
• Agent Chat UI
• Build a voice agent with LangChain
• Memory
• Build a custom RAG agent with LangGraph
• Application structure
• Case studies
• Changelog
• Choosing between Graph and Functional APIs
• LangSmith Deployment
• Durable execution
• Functional API overview
• Graph API overview
• Install LangGraph
• Interrupts
• Run a local server
• LangSmith Observability
• LangGraph overview: Gain control with LangGraph to design agents that reliably handle complex tasks
• Persistence
• LangGraph runtime
• Quickstart
• Streaming
• LangSmith Studio
• Test
• Thinking in LangGraph: Learn how to think about building agents with LangGraph
• Agent Chat UI
• Use the functional API
• Use the graph API
• Subgraphs
• Use time-travel
• Workflows and agents
• Learn: Tutorials, conceptual guides, and resources to help you get started.
• LangChain v1 migration guide
• LangGraph v1 migration guide
• Deep Agents
• LangChain SDK
• LangGraph SDK
• Reference
• Release policy
• Changelog: Log of updates and improvements to our JavaScript/TypeScript packages
• What's new in LangChain v1
• What's new in LangGraph v1
• Security policy
• Versioning
• Errors
• Context overview
• Memory overview
• Frameworks, runtimes, and harnesses: Understand the differences between LangChain, LangGraph, and Deep Agents and when to use each one
• Contributing to code
• Co-marketing
• Contributing to documentation
• Implement a LangChain integration
• Contributing integrations
• Contributing
• Publish an integration
• Using standard tests
• Agent Client Protocol (ACP): Expose Deep Agents over the Agent Client Protocol (ACP) to integrate with code editors and IDEs.
• Backends: Choose and configure filesystem backends for deep agents. You can specify routes to different backends, implement virtual filesystems, and enforce policies.
• Deep Agents CLI: Terminal coding agent built on the Deep Agents SDK
• Custom model providers: Configure any LangChain-compatible model provider for the Deep Agents CLI
• Comparison with OpenCode and Claude Agent SDK: Compare LangChain Deep Agents with OpenCode and Claude Agent SDK to choose the right tool for your use case
• Customize Deep Agents: Learn how to customize deep agents with system prompts, tools, subagents, and more
• Build a data analysis agent: Build an agent that analyzes data files, generates visualizations, and shares results
• Harness capabilities
• Human-in-the-loop: Learn how to configure human approval for sensitive tool operations
• Long-term memory: Learn how to extend deep agents with persistent memory across threads
• Deep Agents overview: Build agents that can plan, use subagents, and leverage file systems for complex tasks
• Quickstart: Build your first deep agent in minutes
• Sandboxes: Execute code in isolated environments with sandbox backends
• Skills: Learn how to extend your deep agent's capabilities with skills
• Frontend: Build React UIs that display real-time subagent streams from deep agents
• Overview: Stream real-time updates from deep agent runs and subagent execution
• Subagents: Learn how to use subagents to delegate work and keep context clean
• Chat model integrations: Integrate with chat models using LangChain Python.
• Document loader integrations: Integrate with document loaders using LangChain Python.
• Middleware integrations: Integrate with middleware using LangChain Python.
• All LangChain Python integration providers
• Anthropic (Claude) integrations: Integrate with Anthropic (Claude) using LangChain Python.
• AWS (Amazon) integrations: Integrate with AWS (Amazon) using LangChain Python.
• Google integrations: Integrate with Google using LangChain Python.
• Groq integrations: Integrate with Groq using LangChain Python.
• Hugging Face integrations: Integrate with Hugging Face using LangChain Python.
• Microsoft integrations: Integrate with Microsoft using LangChain Python.
• Ollama integrations: Integrate with Ollama using LangChain Python.
• OpenAI integrations: Integrate with OpenAI using LangChain Python.
• LangChain Python integrations: Integrate with providers using LangChain Python.
• Retriever integrations: Integrate with retrievers using LangChain Python.
• Text splitter integrations: Integrate with text splitters using LangChain.
• Store integrations: Integrate with stores using LangChain Python.
• Embedding model integrations: Integrate with embedding models using LangChain Python.
• Tool integrations: Integrate with tools using LangChain Python.
• Vector store integrations: Integrate with vector stores using LangChain Python.
• LangChain Academy
• Agents
• Changelog
• Component architecture
• Context engineering in agents
• LangSmith Deployment
• Get help
• Guardrails: Implement safety checks and content filtering for your agents
• Human-in-the-loop
• Install LangChain
• Build a semantic search engine with LangChain
• Long-term memory
• Model Context Protocol (MCP)
• Messages
• Prebuilt middleware: Prebuilt middleware for common agent use cases
• Custom middleware
• Overview: Control and customize agent execution at every step
• Models
• Custom workflow
• Handoffs
• Build customer support with handoffs
• Multi-agent
• Router
• Build a multi-source knowledge base with routing
• Skills
• Build a SQL assistant with on-demand skills
• Subagents
• Build a personal assistant with subagents
• LangSmith Observability
• LangChain overview: LangChain is an open source framework with a pre-built agent architecture and integrations for any model or tool — so you can build agents that adapt as fast as the ecosystem evolves
• Philosophy: LangChain exists to be the easiest place to start building with LLMs, while also being flexible and production-ready.
• Quickstart
• Build a RAG agent with LangChain
• Retrieval
• Runtime
• Short-term memory
• Build a SQL agent
• Frontend: Build generative UIs with real-time streaming from LangChain agents, LangGraph graphs, and custom APIs
• Overview: Stream real-time updates from agent runs
• Structured output
• LangSmith Studio
• Test
• Tools
• Agent Chat UI
• Build a voice agent with LangChain
• Memory
• Build a custom RAG agent with LangGraph
• Application structure
• Case studies
• Changelog
• Choosing between Graph and Functional APIs
• LangSmith Deployment
• Durable execution
• Functional API overview
• Graph API overview
• Install LangGraph
• Interrupts
• Run a local server
• LangSmith Observability
• LangGraph overview: Gain control with LangGraph to design agents that reliably handle complex tasks
• Persistence
• LangGraph runtime
• Quickstart
• Build a custom SQL agent
• Streaming
• LangSmith Studio
• Test
• Thinking in LangGraph: Learn how to think about building agents with LangGraph
• Agent Chat UI
• Use the functional API
• Use the graph API
• Subgraphs
• Use time-travel
• Workflows and agents
• Learn: Tutorials, conceptual guides, and resources to help you get started.
• LangChain v1 migration guide
• LangGraph v1 migration guide
• Deep Agents
• Integrations
• LangChain SDK
• LangGraph SDK
• Reference
• Release policy
• Changelog: Log of updates and improvements to our Python packages
• What's new in LangChain v1
• What's new in LangGraph v1
• Security policy
• Versioning

OpenAPI Specs

• openapi
• agent-server-openapi