879 lines
No EOL
22 KiB
Text
879 lines
No EOL
22 KiB
Text
---
|
|
title: "Building MCP clients"
|
|
description: "Learn how to build your first client in MCP"
|
|
---
|
|
|
|
In this tutorial, you'll learn how to build a client application that connects to MCP servers. It helps to have gone through the [Quickstart tutorial](/quickstart) that guides you through the basic of building your first server.
|
|
|
|
<Tabs>
|
|
<Tab title="Python">
|
|
|
|
## System Requirements
|
|
|
|
Before starting, ensure your system meets these requirements:
|
|
- Mac or Windows computer
|
|
- Latest Python version installed
|
|
- Latest version of `uv` installed
|
|
|
|
## Setting Up Your Environment
|
|
|
|
First, create a new Python project with `uv`:
|
|
|
|
```bash
|
|
# Create project directory
|
|
uv init mcp-client
|
|
cd mcp-client
|
|
|
|
# Create virtual environment
|
|
uv venv
|
|
|
|
# Activate virtual environment
|
|
# On Windows:
|
|
.venv\Scripts\activate
|
|
# On Unix or MacOS:
|
|
source .venv/bin/activate
|
|
|
|
# Install required packages
|
|
uv add mcp anthropic python-dotenv
|
|
|
|
# Remove boilerplate files
|
|
rm hello.py
|
|
|
|
# Create our main file
|
|
touch client.py
|
|
```
|
|
|
|
## Setting Up Your API Key
|
|
|
|
You'll need an Anthropic API key from the [Anthropic Console](https://console.anthropic.com/settings/keys).
|
|
|
|
Create a `.env` file to store it:
|
|
|
|
```bash
|
|
# Create .env file
|
|
touch .env
|
|
```
|
|
|
|
Add your key to the `.env` file:
|
|
```bash
|
|
ANTHROPIC_API_KEY=<your key here>
|
|
```
|
|
|
|
Add `.env` to your `.gitignore`:
|
|
```bash
|
|
echo ".env" >> .gitignore
|
|
```
|
|
|
|
<Warning>
|
|
Make sure you keep your `ANTHROPIC_API_KEY` secure!
|
|
</Warning>
|
|
|
|
## Creating the Client
|
|
|
|
### Basic Client Structure
|
|
First, let's set up our imports and create the basic client class:
|
|
|
|
```python
|
|
import asyncio
|
|
from typing import Optional
|
|
from contextlib import AsyncExitStack
|
|
|
|
from mcp import ClientSession, StdioServerParameters
|
|
from mcp.client.stdio import stdio_client
|
|
|
|
from anthropic import Anthropic
|
|
from dotenv import load_dotenv
|
|
|
|
load_dotenv() # load environment variables from .env
|
|
|
|
class MCPClient:
|
|
def __init__(self):
|
|
# Initialize session and client objects
|
|
self.session: Optional[ClientSession] = None
|
|
self.exit_stack = AsyncExitStack()
|
|
self.anthropic = Anthropic()
|
|
# methods will go here
|
|
```
|
|
|
|
### Server Connection Management
|
|
|
|
Next, we'll implement the method to connect to an MCP server:
|
|
|
|
```python
|
|
async def connect_to_server(self, server_script_path: str):
|
|
"""Connect to an MCP server
|
|
|
|
Args:
|
|
server_script_path: Path to the server script (.py or .js)
|
|
"""
|
|
is_python = server_script_path.endswith('.py')
|
|
is_js = server_script_path.endswith('.js')
|
|
if not (is_python or is_js):
|
|
raise ValueError("Server script must be a .py or .js file")
|
|
|
|
command = "python" if is_python else "node"
|
|
server_params = StdioServerParameters(
|
|
command=command,
|
|
args=[server_script_path],
|
|
env=None
|
|
)
|
|
|
|
stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
|
|
self.stdio, self.write = stdio_transport
|
|
self.session = await self.exit_stack.enter_async_context(ClientSession(self.stdio, self.write))
|
|
|
|
await self.session.initialize()
|
|
|
|
# List available tools
|
|
response = await self.session.list_tools()
|
|
tools = response.tools
|
|
print("\nConnected to server with tools:", [tool.name for tool in tools])
|
|
```
|
|
|
|
### Query Processing Logic
|
|
|
|
Now let's add the core functionality for processing queries and handling tool calls:
|
|
|
|
```python
|
|
async def process_query(self, query: str) -> str:
|
|
"""Process a query using Claude and available tools"""
|
|
messages = [
|
|
{
|
|
"role": "user",
|
|
"content": query
|
|
}
|
|
]
|
|
|
|
response = await self.session.list_tools()
|
|
available_tools = [{
|
|
"name": tool.name,
|
|
"description": tool.description,
|
|
"input_schema": tool.inputSchema
|
|
} for tool in response.tools]
|
|
|
|
# Initial Claude API call
|
|
response = self.anthropic.messages.create(
|
|
model="claude-3-5-sonnet-20241022",
|
|
max_tokens=1000,
|
|
messages=messages,
|
|
tools=available_tools
|
|
)
|
|
|
|
# Process response and handle tool calls
|
|
tool_results = []
|
|
final_text = []
|
|
|
|
for content in response.content:
|
|
if content.type == 'text':
|
|
final_text.append(content.text)
|
|
elif content.type == 'tool_use':
|
|
tool_name = content.name
|
|
tool_args = content.input
|
|
|
|
# Execute tool call
|
|
result = await self.session.call_tool(tool_name, tool_args)
|
|
tool_results.append({"call": tool_name, "result": result})
|
|
final_text.append(f"[Calling tool {tool_name} with args {tool_args}]")
|
|
|
|
# Continue conversation with tool results
|
|
if hasattr(content, 'text') and content.text:
|
|
messages.append({
|
|
"role": "assistant",
|
|
"content": content.text
|
|
})
|
|
messages.append({
|
|
"role": "user",
|
|
"content": result.content
|
|
})
|
|
|
|
# Get next response from Claude
|
|
response = self.anthropic.messages.create(
|
|
model="claude-3-5-sonnet-20241022",
|
|
max_tokens=1000,
|
|
messages=messages,
|
|
)
|
|
|
|
final_text.append(response.content[0].text)
|
|
|
|
return "\n".join(final_text)
|
|
```
|
|
|
|
### Interactive Chat Interface
|
|
Now we'll add the chat loop and cleanup functionality:
|
|
|
|
```python
|
|
async def chat_loop(self):
|
|
"""Run an interactive chat loop"""
|
|
print("\nMCP Client Started!")
|
|
print("Type your queries or 'quit' to exit.")
|
|
|
|
while True:
|
|
try:
|
|
query = input("\nQuery: ").strip()
|
|
|
|
if query.lower() == 'quit':
|
|
break
|
|
|
|
response = await self.process_query(query)
|
|
print("\n" + response)
|
|
|
|
except Exception as e:
|
|
print(f"\nError: {str(e)}")
|
|
|
|
async def cleanup(self):
|
|
"""Clean up resources"""
|
|
await self.exit_stack.aclose()
|
|
```
|
|
|
|
### Main Entry Point
|
|
|
|
Finally, we'll add the main execution logic:
|
|
|
|
```python
|
|
async def main():
|
|
if len(sys.argv) < 2:
|
|
print("Usage: python client.py <path_to_server_script>")
|
|
sys.exit(1)
|
|
|
|
client = MCPClient()
|
|
try:
|
|
await client.connect_to_server(sys.argv[1])
|
|
await client.chat_loop()
|
|
finally:
|
|
await client.cleanup()
|
|
|
|
if __name__ == "__main__":
|
|
import sys
|
|
asyncio.run(main())
|
|
```
|
|
|
|
You can find the complete `client.py` file [here.](https://gist.github.com/zckly/f3f28ea731e096e53b39b47bf0a2d4b1)
|
|
|
|
## Key Components Explained
|
|
|
|
### 1. Client Initialization
|
|
- The `MCPClient` class initializes with session management and API clients
|
|
- Uses `AsyncExitStack` for proper resource management
|
|
- Configures the Anthropic client for Claude interactions
|
|
|
|
### 2. Server Connection
|
|
- Supports both Python and Node.js servers
|
|
- Validates server script type
|
|
- Sets up proper communication channels
|
|
- Initializes the session and lists available tools
|
|
|
|
### 3. Query Processing
|
|
- Maintains conversation context
|
|
- Handles Claude's responses and tool calls
|
|
- Manages the message flow between Claude and tools
|
|
- Combines results into a coherent response
|
|
|
|
### 4. Interactive Interface
|
|
- Provides a simple command-line interface
|
|
- Handles user input and displays responses
|
|
- Includes basic error handling
|
|
- Allows graceful exit
|
|
|
|
### 5. Resource Management
|
|
- Proper cleanup of resources
|
|
- Error handling for connection issues
|
|
- Graceful shutdown procedures
|
|
|
|
## Common Customization Points
|
|
|
|
1. **Tool Handling**
|
|
- Modify `process_query()` to handle specific tool types
|
|
- Add custom error handling for tool calls
|
|
- Implement tool-specific response formatting
|
|
|
|
2. **Response Processing**
|
|
- Customize how tool results are formatted
|
|
- Add response filtering or transformation
|
|
- Implement custom logging
|
|
|
|
3. **User Interface**
|
|
- Add a GUI or web interface
|
|
- Implement rich console output
|
|
- Add command history or auto-completion
|
|
|
|
## Running the Client
|
|
|
|
To run your client with any MCP server:
|
|
|
|
```bash
|
|
uv run client.py path/to/server.py # python server
|
|
uv run client.py path/to/build/index.js # node server
|
|
```
|
|
|
|
The client will:
|
|
1. Connect to the specified server
|
|
2. List available tools
|
|
3. Start an interactive chat session where you can:
|
|
- Enter queries
|
|
- See tool executions
|
|
- Get responses from Claude
|
|
|
|
Here's an example of what it should look like if connected to the weather server from the quickstart:
|
|
|
|
<Frame>
|
|
<img src="/images/client-claude-cli-python.png" />
|
|
</Frame>
|
|
|
|
## How It Works
|
|
|
|
When you submit a query:
|
|
|
|
1. The client gets the list of available tools from the server
|
|
2. Your query is sent to Claude along with tool descriptions
|
|
3. Claude decides which tools (if any) to use
|
|
4. The client executes any requested tool calls through the server
|
|
5. Results are sent back to Claude
|
|
6. Claude provides a natural language response
|
|
7. The response is displayed to you
|
|
|
|
## Best practices
|
|
|
|
1. **Error Handling**
|
|
- Always wrap tool calls in try-catch blocks
|
|
- Provide meaningful error messages
|
|
- Gracefully handle connection issues
|
|
|
|
2. **Resource Management**
|
|
- Use `AsyncExitStack` for proper cleanup
|
|
- Close connections when done
|
|
- Handle server disconnections
|
|
|
|
3. **Security**
|
|
- Store API keys securely in `.env`
|
|
- Validate server responses
|
|
- Be cautious with tool permissions
|
|
|
|
## Troubleshooting
|
|
|
|
### Server Path Issues
|
|
- Double-check the path to your server script is correct
|
|
- Use the absolute path if the relative path isn't working
|
|
- For Windows users, make sure to use forward slashes (/) or escaped backslashes (\\) in the path
|
|
- Verify the server file has the correct extension (.py for Python or .js for Node.js)
|
|
|
|
Example of correct path usage:
|
|
```bash
|
|
# Relative path
|
|
uv run client.py ./server/weather.py
|
|
|
|
# Absolute path
|
|
uv run client.py /Users/username/projects/mcp-server/weather.py
|
|
|
|
# Windows path (either format works)
|
|
uv run client.py C:/projects/mcp-server/weather.py
|
|
uv run client.py C:\\projects\\mcp-server\\weather.py
|
|
```
|
|
|
|
### Response Timing
|
|
- The first response might take up to 30 seconds to return
|
|
- This is normal and happens while:
|
|
- The server initializes
|
|
- Claude processes the query
|
|
- Tools are being executed
|
|
- Subsequent responses are typically faster
|
|
- Don't interrupt the process during this initial waiting period
|
|
|
|
### Common Error Messages
|
|
|
|
If you see:
|
|
- `FileNotFoundError`: Check your server path
|
|
- `Connection refused`: Ensure the server is running and the path is correct
|
|
- `Tool execution failed`: Verify the tool's required environment variables are set
|
|
- `Timeout error`: Consider increasing the timeout in your client configuration
|
|
|
|
</Tab>
|
|
<Tab title="Node">
|
|
## System Requirements
|
|
|
|
Before starting, ensure your system meets these requirements:
|
|
- Mac or Windows computer
|
|
- Node.js version 16 or higher installed
|
|
- npm (comes with Node.js)
|
|
|
|
## Setting Up Your Environment
|
|
|
|
First, create a new Node.js project:
|
|
|
|
```bash
|
|
# Create project directory
|
|
mkdir mcp-client
|
|
cd mcp-client
|
|
|
|
# Initialize npm project
|
|
npm init -y
|
|
|
|
# Install dependencies
|
|
npm install @modelcontextprotocol/sdk @anthropic-ai/sdk dotenv
|
|
npm install -D typescript @types/node
|
|
|
|
# Create TypeScript config
|
|
npx tsc --init
|
|
|
|
# Create necessary files
|
|
mkdir src
|
|
touch src/client.ts
|
|
touch .env
|
|
```
|
|
|
|
Update your `package.json` to add necessary configuration:
|
|
|
|
```json
|
|
{
|
|
"type": "module",
|
|
"scripts": {
|
|
"build": "tsc",
|
|
"start": "node build/client.js"
|
|
}
|
|
}
|
|
```
|
|
|
|
Update your `tsconfig.json` with appropriate settings:
|
|
|
|
```json
|
|
{
|
|
"compilerOptions": {
|
|
"target": "ES2022",
|
|
"module": "Node16",
|
|
"moduleResolution": "Node16",
|
|
"outDir": "./build",
|
|
"rootDir": "./src",
|
|
"strict": true,
|
|
"esModuleInterop": true,
|
|
"skipLibCheck": true,
|
|
"forceConsistentCasingInFileNames": true
|
|
},
|
|
"include": ["src/**/*"]
|
|
}
|
|
```
|
|
|
|
## Setting Up Your API Key
|
|
|
|
You'll need an Anthropic API key from the [Anthropic Console](https://console.anthropic.com/settings/keys).
|
|
|
|
Create a `.env` file:
|
|
```bash
|
|
ANTHROPIC_API_KEY=your_key_here
|
|
```
|
|
|
|
Add `.env` to your `.gitignore`:
|
|
```bash
|
|
echo ".env" >> .gitignore
|
|
```
|
|
|
|
## Creating the Client
|
|
|
|
First, let's set up our imports and create the basic client class in `src/client.ts`:
|
|
|
|
```typescript
|
|
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
|
|
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
|
|
import Anthropic from "@anthropic-ai/sdk";
|
|
import dotenv from "dotenv";
|
|
import { Tool } from "@anthropic-ai/sdk/resources/messages.js";
|
|
import {
|
|
CallToolResultSchema,
|
|
ListToolsResultSchema,
|
|
} from "@modelcontextprotocol/sdk/types.js";
|
|
import * as readline from "node:readline";
|
|
|
|
dotenv.config();
|
|
|
|
interface MCPClientConfig {
|
|
name?: string;
|
|
version?: string;
|
|
}
|
|
|
|
class MCPClient {
|
|
private client: Client | null = null;
|
|
private anthropic: Anthropic;
|
|
private transport: StdioClientTransport | null = null;
|
|
|
|
constructor(config: MCPClientConfig = {}) {
|
|
this.anthropic = new Anthropic();
|
|
}
|
|
|
|
// Methods will go here
|
|
}
|
|
```
|
|
|
|
## Server Connection Management
|
|
|
|
Next, implement the method to connect to an MCP server:
|
|
|
|
```typescript
|
|
async connectToServer(serverScriptPath: string): Promise<void> {
|
|
const isPython = serverScriptPath.endsWith(".py");
|
|
const isJs = serverScriptPath.endsWith(".js");
|
|
|
|
if (!isPython && !isJs) {
|
|
throw new Error("Server script must be a .py or .js file");
|
|
}
|
|
|
|
const command = isPython ? "python" : "node";
|
|
|
|
this.transport = new StdioClientTransport({
|
|
command,
|
|
args: [serverScriptPath],
|
|
});
|
|
|
|
this.client = new Client(
|
|
{
|
|
name: "mcp-client",
|
|
version: "1.0.0",
|
|
},
|
|
{
|
|
capabilities: {},
|
|
}
|
|
);
|
|
|
|
await this.client.connect(this.transport);
|
|
|
|
// List available tools
|
|
const response = await this.client.request(
|
|
{ method: "tools/list" },
|
|
ListToolsResultSchema
|
|
);
|
|
|
|
console.log(
|
|
"\nConnected to server with tools:",
|
|
response.tools.map((tool: any) => tool.name)
|
|
);
|
|
}
|
|
```
|
|
|
|
## Query Processing Logic
|
|
|
|
Now add the core functionality for processing queries and handling tool calls:
|
|
|
|
```typescript
|
|
async processQuery(query: string): Promise<string> {
|
|
if (!this.client) {
|
|
throw new Error("Client not connected");
|
|
}
|
|
|
|
// Initialize messages array with user query
|
|
let messages: Anthropic.MessageParam[] = [
|
|
{
|
|
role: "user",
|
|
content: query,
|
|
},
|
|
];
|
|
|
|
// Get available tools
|
|
const toolsResponse = await this.client.request(
|
|
{ method: "tools/list" },
|
|
ListToolsResultSchema
|
|
);
|
|
|
|
const availableTools: Tool[] = toolsResponse.tools.map((tool: any) => ({
|
|
name: tool.name,
|
|
description: tool.description,
|
|
input_schema: tool.inputSchema,
|
|
}));
|
|
|
|
const finalText: string[] = [];
|
|
let currentResponse = await this.anthropic.messages.create({
|
|
model: "claude-3-5-sonnet-20241022",
|
|
max_tokens: 1000,
|
|
messages,
|
|
tools: availableTools,
|
|
});
|
|
|
|
// Process the response and any tool calls
|
|
while (true) {
|
|
// Add Claude's response to final text and messages
|
|
for (const content of currentResponse.content) {
|
|
if (content.type === "text") {
|
|
finalText.push(content.text);
|
|
} else if (content.type === "tool_use") {
|
|
const toolName = content.name;
|
|
const toolArgs = content.input;
|
|
|
|
// Execute tool call
|
|
const result = await this.client.request(
|
|
{
|
|
method: "tools/call",
|
|
params: {
|
|
name: toolName,
|
|
args: toolArgs,
|
|
},
|
|
},
|
|
CallToolResultSchema
|
|
);
|
|
|
|
finalText.push(
|
|
`[Calling tool ${toolName} with args ${JSON.stringify(toolArgs)}]`
|
|
);
|
|
|
|
// Add Claude's response (including tool use) to messages
|
|
messages.push({
|
|
role: "assistant",
|
|
content: currentResponse.content,
|
|
});
|
|
|
|
// Add tool result to messages
|
|
messages.push({
|
|
role: "user",
|
|
content: [
|
|
{
|
|
type: "tool_result",
|
|
tool_use_id: content.id,
|
|
content: [
|
|
{ type: "text", text: JSON.stringify(result.content) },
|
|
],
|
|
},
|
|
],
|
|
});
|
|
|
|
// Get next response from Claude with tool results
|
|
currentResponse = await this.anthropic.messages.create({
|
|
model: "claude-3-5-sonnet-20241022",
|
|
max_tokens: 1000,
|
|
messages,
|
|
tools: availableTools,
|
|
});
|
|
|
|
// Add Claude's interpretation of the tool results to final text
|
|
if (currentResponse.content[0]?.type === "text") {
|
|
finalText.push(currentResponse.content[0].text);
|
|
}
|
|
|
|
// Continue the loop to process any additional tool calls
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// If we reach here, there were no tool calls in the response
|
|
break;
|
|
}
|
|
|
|
return finalText.join("\n");
|
|
}
|
|
|
|
```
|
|
|
|
## Interactive Chat Interface
|
|
|
|
Add the chat loop and cleanup functionality:
|
|
|
|
```typescript
|
|
async chatLoop(): Promise<void> {
|
|
console.log("\nMCP Client Started!");
|
|
console.log("Type your queries or 'quit' to exit.");
|
|
|
|
// Using Node's readline for console input
|
|
const rl = readline.createInterface({
|
|
input: process.stdin,
|
|
output: process.stdout,
|
|
});
|
|
|
|
const askQuestion = () => {
|
|
rl.question("\nQuery: ", async (query: string) => {
|
|
try {
|
|
if (query.toLowerCase() === "quit") {
|
|
await this.cleanup();
|
|
rl.close();
|
|
return;
|
|
}
|
|
|
|
const response = await this.processQuery(query);
|
|
console.log("\n" + response);
|
|
askQuestion();
|
|
} catch (error) {
|
|
console.error("\nError:", error);
|
|
askQuestion();
|
|
}
|
|
});
|
|
};
|
|
|
|
askQuestion();
|
|
}
|
|
|
|
async cleanup(): Promise<void> {
|
|
if (this.transport) {
|
|
await this.transport.close();
|
|
}
|
|
}
|
|
```
|
|
|
|
## Main Entry Point
|
|
|
|
Finally, add the main execution logic outside the class:
|
|
|
|
```typescript
|
|
// Main execution
|
|
async function main() {
|
|
if (process.argv.length < 3) {
|
|
console.log("Usage: ts-node client.ts <path_to_server_script>");
|
|
process.exit(1);
|
|
}
|
|
|
|
const client = new MCPClient();
|
|
try {
|
|
await client.connectToServer(process.argv[2]);
|
|
await client.chatLoop();
|
|
} catch (error) {
|
|
console.error("Error:", error);
|
|
await client.cleanup();
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
// Run main if this is the main module
|
|
if (import.meta.url === new URL(process.argv[1], "file:").href) {
|
|
main();
|
|
}
|
|
|
|
export default MCPClient;
|
|
```
|
|
|
|
## Running the Client
|
|
|
|
To run your client with any MCP server:
|
|
|
|
```bash
|
|
# Build the TypeScript code. Make sure to rerun this every time you update `client.ts`!
|
|
npm run build
|
|
|
|
# Run the client
|
|
node build/client.js path/to/server.py # for Python servers
|
|
node build/client.js path/to/server.js # for Node.js servers
|
|
```
|
|
|
|
The client will:
|
|
1. Connect to the specified server
|
|
2. List available tools
|
|
3. Start an interactive chat session where you can:
|
|
- Enter queries
|
|
- See tool executions
|
|
- Get responses from Claude
|
|
|
|
## Key Components Explained
|
|
|
|
#### 1. Client Initialization
|
|
- The `MCPClient` class initializes with session management and API clients
|
|
- Sets up the MCP client with basic capabilities
|
|
- Configures the Anthropic client for Claude interactions
|
|
|
|
#### 2. Server Connection
|
|
- Supports both Python and Node.js servers
|
|
- Validates server script type
|
|
- Sets up proper communication channels
|
|
- Lists available tools on connection
|
|
|
|
#### 3. Query Processing
|
|
- Maintains conversation context
|
|
- Handles Claude's responses and tool calls
|
|
- Manages the message flow between Claude and tools
|
|
- Combines results into a coherent response
|
|
|
|
#### 4. Interactive Interface
|
|
- Provides a simple command-line interface
|
|
- Handles user input and displays responses
|
|
- Includes basic error handling
|
|
- Allows graceful exit
|
|
|
|
#### 5. Resource Management
|
|
- Proper cleanup of resources
|
|
- Error handling for connection issues
|
|
- Graceful shutdown procedures
|
|
|
|
### Common Customization Points
|
|
|
|
1. **Tool Handling**
|
|
- Modify `processQuery()` to handle specific tool types
|
|
- Add custom error handling for tool calls
|
|
- Implement tool-specific response formatting
|
|
|
|
2. **Response Processing**
|
|
- Customize how tool results are formatted
|
|
- Add response filtering or transformation
|
|
- Implement custom logging
|
|
|
|
3. **User Interface**
|
|
- Add a GUI or web interface
|
|
- Implement rich console output
|
|
- Add command history or auto-completion
|
|
|
|
### Best Practices
|
|
|
|
1. **Error Handling**
|
|
- Always wrap tool calls in try-catch blocks
|
|
- Provide meaningful error messages
|
|
- Gracefully handle connection issues
|
|
|
|
2. **Resource Management**
|
|
- Use proper cleanup methods
|
|
- Close connections when done
|
|
- Handle server disconnections
|
|
|
|
3. **Security**
|
|
- Store API keys securely in `.env`
|
|
- Validate server responses
|
|
- Be cautious with tool permissions
|
|
|
|
### Troubleshooting
|
|
|
|
#### Server Path Issues
|
|
- Double-check the path to your server script
|
|
- Use absolute paths if relative paths aren't working
|
|
- For Windows users, use forward slashes (/) or escaped backslashes (\\)
|
|
- Verify the server file has the correct extension (.py or .js)
|
|
|
|
Example of correct path usage:
|
|
```bash
|
|
# Relative path
|
|
node build/client.js ./server/weather.js
|
|
|
|
# Absolute path
|
|
node build/client.js /Users/username/projects/mcp-server/weather.js
|
|
|
|
# Windows path (either format works)
|
|
node build/client.js C:/projects/mcp-server/weather.js
|
|
node build/client.js C:\\projects\\mcp-server\\weather.js
|
|
```
|
|
|
|
#### Connection Issues
|
|
- Verify the server script exists and has correct permissions
|
|
- Check that the server script is executable
|
|
- Ensure the server script's dependencies are installed
|
|
- Try running the server script directly to check for errors
|
|
|
|
#### Tool Execution Issues
|
|
- Check server logs for error messages
|
|
- Verify tool input arguments match the schema
|
|
- Ensure tool dependencies are available
|
|
- Add debug logging to track execution flow
|
|
</Tab>
|
|
</Tabs>
|
|
|
|
## Next steps
|
|
|
|
<CardGroup cols={1}>
|
|
<Card
|
|
title="Building a local fileserver"
|
|
icon="files"
|
|
href="/examples"
|
|
>
|
|
Build an intermediate MCP server that communicates with your local filesystem
|
|
</Card>
|
|
<Card
|
|
title="Example servers"
|
|
icon="grid"
|
|
href="/examples"
|
|
>
|
|
Check out our gallery of official MCP servers and implementations
|
|
</Card>
|
|
<Card
|
|
title="Core architecture"
|
|
icon="sitemap"
|
|
href="/docs/concepts/architecture"
|
|
>
|
|
Understand how MCP connects clients, servers, and LLMs
|
|
</Card>
|
|
</CardGroup> |