langchain-ai/langchain-mcp-adapters

Features

• Agentic Workflow Orchestration - Implements a system for managing the execution and state persistence of AI agents across synchronous and asynchronous runs.
• Agent Communication Protocols - Implements the Model Context Protocol to expose assistants as compliant agents for seamless inter-agent interaction.
• Long-term Memory Stores - Implements persistent storage mechanisms to retain context across multiple user sessions and threads.
• Recurring Agent Scheduling - Enables periodic agent invocations on a fixed timetable, supporting both isolated and state-sharing runs.
• Agent-to-Agent Communication - Implements standardized interfaces and protocols to facilitate direct communication and coordination between different AI agents.
• Agent Context Management - Versions and organizes bundles of instructions and tools to ensure consistent agent behavior.
• Agent Deployment Management - Provides comprehensive management of agent server deployments, including creation, updates, and status monitoring.
• Agent Deployment Runtimes - Provides a runtime environment that manages execution, state, and persistence for deployed agent graphs.
• Agent State Persistence - Executes assistants on specific threads to update and persist conversational state based on accumulated outputs.
• Assistant Metadata - Provides operations for retrieving and inspecting the configuration and metadata of specific assistant instances.
• Agent Tooling Protocols - Implements standardized communication specifications to transform Model Context Protocol tools for use in agent frameworks.
• Agent Instantiation - Implements the process of creating active agent instances from specific configuration settings and graphs.
• Durable Execution Runtimes - Automatically saves runtime state via checkpointing to enable recovery of agent processes from the exact point of failure.
• Model Context Protocol - Implements the Model Context Protocol to connect AI models to local data sources and external tools.
• Multi-Protocol Tool Exposures - Makes internal agent capabilities accessible as compliant tools for any client implementing the Model Context Protocol.
• Assistant Configuration Updates - Enables modification of an assistant's name, description, and graph association via patch requests.
• External Tool Integrations - Provides connectors for bridging external tool schemas and communication protocols into agent logic graphs.
• MCP Protocol Integrations - Wraps Model Context Protocol tools into compatible formats specifically for LangChain agent workflows and graphs.
• Protocol Tool Converters - Wraps Model Context Protocol tools to make them accessible to external agent workflows and graphs.
• Conversation Session Initializers - Implements mechanisms for bootstrapping conversation contexts and initializing stateful sessions.
• MCP Servers - Exposes AI agents as Model Context Protocol (MCP) servers so external clients can discover and use their capabilities.
• Model Context Protocol Implementations - Implements a bridge that converts Model Context Protocol tools into compatible formats for agent frameworks.
• Agent Graph Packaging - Provides a CLI to develop, test, and bundle agent computational graphs into deployable packages.
• Background Task Runners - Runs agents asynchronously in the background without blocking the caller while maintaining state and lifecycle.
• Deployment Management - Provides tools to list, delete, and monitor runtime and build logs for managed server deployments.
• Agent Run Scheduling - Triggers periodic execution of agent graphs or assistants on new threads using cron schedules.
• AI Protocol Translation - Transforms Model Context Protocol tool definitions into formats compatible with agent frameworks and logic graphs.
• JSON-RPC Implementations - Implements JSON-RPC for transmitting requests and notifications to servers using stateless HTTP transport.
• Agent-to-Agent JSON-RPC - Facilitates the exchange of messages and task state tracking between AI agents using JSON-RPC over HTTP.
• Thread State History - Fetches past states for specific threads to reconstruct previous agent states using metadata filters.
• Agent Thread State Persistence - Persists conversation history and checkpoints to allow agents to maintain context across sessions.
• Tool Exposure Interfaces - Wraps internal agent functions and graphs to expose them as compliant tools for external protocol clients.
• Agent Execution Streaming - Provides real-time streaming of agent execution results from conversation threads to clients via open connections.
• Agent Thread Command Interfaces - Sends scoped protocol commands to agent threads via HTTP or WebSockets to trigger actions like starting runs.
• Assistant Graph Retrieval - Allows fetching the graph representation of a configured assistant, including depth-limited views.
• Repository Management - Manages the creation, retrieval, and deletion of agent skill and instruction repositories.
• Human-in-the-loop Workflows - Provides mechanisms for pausing agent execution to allow human review or approval of tool calls.
• Agent Authentication - Handles OAuth 2.0 flows for agents, including pausing execution for user consent and token refreshing.
• Agent Streaming Interfaces - Streams agent execution events, including tool calls and assistant deltas, for a specific thread.
• Concurrency Managers - Manages concurrent agent runs by controlling how new messages are queued or canceled while a run is in progress.
• Event-Driven Model Streaming - Delivers real-time agent responses and execution updates using an event-driven streaming architecture.
• Environment-Based Promotion - Promotes versioned agent configurations and instructions through development, staging, and production environments.
• Agent Response Streams - Streams agent responses and tool results incrementally to clients in real time.
• Remote Agent Management - Supplies programmatic interfaces and remote connection tools to manage AI graphs as if they were local.
• Remote Tool Integrations - Unifies available capabilities from multiple remote tool servers into a single client interface.
• Stateless Run Executions - Implements stateless graph invocations that return a run identifier immediately for background processing.
• Tool Error Handling - Provides logic for reporting external tool execution failures back to the model to allow for self-correction.
• Agent Execution Traces - Transforms execution traces into structured dataset entries for monitoring and replay debugging.
• Schema Enforcement Tools - Validates input and output data formats using JSON schemas to ensure processing consistency.
• Assistant Subgraph Retrieval - Enables fetching of subgraphs associated with an assistant, filtered by namespace with recursive options.
• OAuth Provider Registrations - Implements automated registration of OAuth providers using auto-discovery to facilitate secure tool authentication.
• Local Development Servers - Ships a lightweight local server with hot reloading and debugging for rapid agent testing.
• Deployment Revisions - Retrieves the history of deployment versions to track changes and manage release cycles.
• Scheduled Task Querying - Filters and retrieves active periodic task configurations based on assistant IDs, thread IDs, or metadata.
• Thread Pruning - Supports removing specific conversation threads and their accumulated outputs to optimize storage.
• Agent Versioning - Provides systems for tracking and selecting specific agent deployment versions at runtime.
• Docker Image Building - Generates Docker images or standalone Dockerfiles based on project configuration for agent deployment.
• Custom Container Images - Allows injecting custom shell commands into the container build process to install system dependencies.
• Redeployments - Triggers the redeployment of specific previous revisions of an agent server to production via API.
• Job Scheduling & Configuration - Allows updating the execution schedule, timezone, and runtime configuration of recurring background tasks.
• Managed Agent Hosting - Builds and pushes server images to managed registries to create or update remote deployments.
• Run Cancellations - Allows stopping active agent executions by targeting specific thread and run identifiers.
• Synchronous Run Executions - Supports triggering tasks within a thread while holding the connection open until the final output is produced.
• Real-time Event Streams - Sends structured command and event data over SSE or WebSockets to provide real-time activity updates.
• OAuth Provider Integrations - Enables registration and configuration of external OAuth providers like Google and GitHub for secure access.
• OAuth Token Validators - Verifies the existence and validity of active OAuth tokens for specific providers across associated agents.
• Long-Running Task Output Streams - Streams real-time output from active agent runs with support for resuming from specific event IDs.
• Stateful Execution Resumption - Enables restoring execution to prior states to investigate errors or explore alternative agent execution paths.
• Data Validation Schemas - Enforces consistent input and output formats using predefined JSON schemas for reliable inter-agent communication.
• Stateless Response Streaming - Provides incremental delivery of responses via server-sent events for stateless graph or assistant executions.
• Asynchronous Agent Job Execution - Provides the ability to trigger and manage long-running agent tasks asynchronously without blocking the caller.
• AI Agent Execution Monitors - Provides real-time monitoring of active agent executions on specific threads until completion.
• Scheduled Task Deletion - Provides a mechanism to remove periodic tasks by identifier to stop automated background recurrence.
• Run Metadata Retrieval - Enables retrieval of current status, metadata, and execution history for specific agent invocations.
• Resumable Event Streams - Implements resumable event streams over SSE for agent threads, including sequence-based reconnection to replay missed data.
• Agent Frameworks - Bridges Anthropic MCP tools with agent workflows.
• Developer Tools - Adapters to make Model Context Protocol tools compatible with AI agents.
• LangGraph Extensions - Compatibility layer for using MCP tools within LangChain environments.

Star history