MCP Server Adapter

Description

The mcp-server-adapter is a Go package designed to simplify the integration of Model Context Protocol (MCP) servers with LangChain Go applications. It acts as an intermediary, allowing LangChain agents to seamlessly discover, use, and manage tools exposed by various MCP servers. This adapter handles server lifecycle management, configuration watching, and the conversion of MCP tools into a format consumable by LangChain.

Note: This project is currently a work in progress. While functional, it may undergo significant changes, including breaking API changes, as it evolves.

Features

• Seamless LangChain Integration: Exposes MCP server tools as native LangChain tools.Tool objects.
• MCP Server Lifecycle Management: Start, stop, and monitor the status of multiple MCP servers.
• Dynamic Configuration: Supports loading server configurations from a JSON file and hot-reloading changes.
• Server Status and Configuration Access: Easily check if a server is disabled or retrieve its full configuration.
• File Watcher: Automatically detects and reacts to changes in the configuration file, restarting affected servers.
• Multiple Transport Support: Connects to MCP servers via standard I/O (stdio), Server-Sent Events (SSE), and HTTP transports.
• Robust Error Handling: Includes mechanisms for safely closing server connections and handling common errors.
• Extensible: Designed with interfaces for easy extension and testing (e.g., custom client factories).

Installation

This project requires Go 1.21 or higher.

1. Clone the repository:

   git clone https://github.com/denkhaus/mcp-server-adapter.git
   cd mcp-server-adapter
   

2. Install dependencies:

   go mod tidy
   

3. Build the project:

   go build ./...
   

Running Examples

The examples can be built and run using the provided Makefile. Navigate to the project root and use make commands.

For instance, to build all examples:

make build-examples

To run a specific example, like the demo:

make run-demo

Usage

The mcp-server-adapter is typically used within a Go application to manage connections to MCP servers and integrate their tools into an LLM agent.

1. Define your MCP server configuration: Create a JSON file (e.g., config.json) specifying the MCP servers your application needs to connect to. See examples/mcp-spec-config.json for a practical example.

   {
     "mcpServers": {
       "fetcher": {
         "command": "npx",
         "args": ["-y", "fetcher-mcp"],
         "transport": "stdio"
       },
       "tavily-mcp": {
         "command": "npx",
         "args": ["-y", "tavily-mcp@0.1.3"],
         "transport": "stdio"
       }
     }
   }
   

2. Initialize the adapter:

   package main
   
   import (
   	"context"
   	"log"
   	"time"
   
   	"github.com/denkhaus/mcp-server-adapter"
   )
   
   func main() {
   	adapter, err := mcpadapter.New(
   		mcpadapter.WithConfigPath("./config.json"),
   		mcpadapter.WithLogLevel("info"),
   		mcpadapter.WithFileWatcher(true), // Enable hot-reloading of config
   	)
   	if err != nil {
   		log.Fatalf("Failed to create MCP adapter: %v", err)
   	}
   	defer adapter.Close()
   
       ctx := context.Background()
   
   	// Start all configured MCP servers
   	if err := adapter.StartAllServers(ctx); err != nil {
   		log.Fatalf("Failed to start all MCP servers: %v", err)
   	}
   
   	// Wait for servers to be ready
   	if err := adapter.WaitForServersReady(ctx, 30*time.Second); err != 
   

... View full README on GitHub