Zum Inhalt

Modell Context Protocol (MCP) Server Cheat Sheet

Überblick

Model Context Protocol (MCP) ist ein universeller, offener Standard, der KI-Systeme mit externen Datenquellen und Tools verbindet. MCP-Server fungieren als Brücke zwischen KI-Modellen (Klients) und der Außenwelt, sodass KI-Assistenten Funktionen zugreifen und aufrufen können, Informationen abrufen und mit verschiedenen Dienstleistungen standardisiert interagieren.

Was MCP auseinandersetzt, ist seine Fähigkeit, fragmentierte Integrationen durch ein einziges, einheitliches Protokoll zu ersetzen. Vor MCP verfügte jeder KI-Modellanbieter über eigene proprietäre Methoden für den Werkzeuggebrauch und den Funktionsaufruf, wodurch ein komplexes Ökosystem geschaffen wurde, das Entwickler benötigte, um verschiedene Integrationsansätze für jedes Modell umzusetzen. MCP löst dies durch die Bereitstellung einer standardisierten Schnittstelle, die über verschiedene KI-Modelle und -Dienste hinweg arbeitet und die Entwicklung und den Einsatz von KI-Anwendungen erheblich vereinfacht.

MCP-Server sind als kritische Komponente im KI-Infrastrukturstapel entstanden, wodurch Organisationen sichere, skalierbare und standardisierte Verbindungen zwischen ihren KI-Modellen und den Werkzeugen, Datenquellen und Diensten aufbauen können, die sie benötigen. Ob auf Cloud-Plattformen oder On-Premises implementiert, MCP-Server ermöglichen es KI-Systeme, sicher und effizient mit der externen Welt zu interagieren und dabei die Kontrolle über diese Interaktionen zu erhalten.

Kernkonzepte

Modellkontextprotokoll (MCP)

MCP ist das standardisierte Protokoll, das definiert, wie KI-Modelle mit externen Tools und Services interagieren. Es bietet eine universelle Schnittstelle zur Verbindung von KI-Systemen mit Datenquellen und -funktionen.

MCP Server

Ein MCP-Server implementiert das Model Context Protocol und fungiert als Brücke zwischen KI-Modellen (Clients) und externen Werkzeugen oder Dienstleistungen. Es behandelt Anfragen von AI-Modellen, führt die entsprechenden Funktionen aus und gibt Ergebnisse zurück.

MCP Client

Ein MCP-Client ist jedes AI-Modell oder jede Anwendung, die mit einem MCP-Server kommuniziert, um auf externe Tools und Dienste zuzugreifen. Clients senden Anfragen an den Server und erhalten Antworten entsprechend der MCP-Spezifikation.

Werkzeuge

Tools sind Funktionen oder Dienste, die ein MCP-Server AI-Modellen zur Verfügung stellt. Dazu gehören Datenabruffunktionen, Rechenwerkzeuge, API-Integrationen oder jede andere Möglichkeit, die die Funktionalität des AI-Modells erweitert.

Kontext

Kontext bezieht sich auf die Informationen und Fähigkeiten, die einem AI-Modell über den MCP-Server zur Verfügung stehen. Dazu gehören die Werkzeuge, auf die das Modell zugreifen kann, die Daten, die es abrufen kann, und die Operationen, die es ausführen kann.

Installation und Inbetriebnahme

AWS Serverless MCP Server

```bash

Clone the AWS Serverless MCP Server repository

git clone https://github.com/aws-samples/aws-serverless-mcp-server.git cd aws-serverless-mcp-server

Install dependencies

npm install

Deploy using AWS CDK

npm run cdk bootstrap npm run cdk deploy ```_

Basic Node.js MCP Server

```javascript // Install dependencies // npm install express cors body-parser

const express = require('express'); const cors = require('cors'); const bodyParser = require('body-parser');

const app = express(); app.use(cors()); app.use(bodyParser.json());

// Define available tools const tools = \\{ get_weather: async (params) => \\{ const \\{ location \\} = params; // Implement weather retrieval logic return \\{ temperature: 25, conditions: "Sunny", location \\}; \\}, search_database: async (params) => \\{ const \\{ query \\} = params; // Implement database search logic return \\{ results: [Result for: $\\{query\\}] \\}; \\} \\};

// MCP server endpoint app.post('/mcp', async (req, res) => \\{ try \\{ const \\{ tool, parameters \\} = req.body;

if (!tools[tool]) \\\\{
  return res.status(400).json(\\\\{ error: `Tool '$\\{tool\\}' not found` \\\\});
\\\\}

const result = await tools[tool](parameters);
res.json(\\\\{ result \\\\});

\\} catch (error) \\{ res.status(500).json(\\{ error: error.message \\}); \\} \\});

// Start server | const PORT = process.env.PORT | | 3000; | app.listen(PORT, () => \\{ console.log(MCP Server running on port $\\{PORT\\}); \\}); ```_

Python MCP Server

```python

Install dependencies

pip install fastapi uvicorn pydantic

from fastapi import FastAPI, HTTPException from pydantic import BaseModel from typing import Dict, Any, Optional import uvicorn

app = FastAPI()

Define request model

class MCPRequest(BaseModel): tool: str parameters: Dict[str, Any]

Define available tools

async def get_weather(location: str) -> Dict[str, Any]: # Implement weather retrieval logic return \\{"temperature": 25, "conditions": "Sunny", "location": location\\}

async def search_database(query: str) -> Dict[str, Any]: # Implement database search logic return \\{"results": [f"Result for: \\{query\\}"]\\}

Tool registry

tools = \\{ "get_weather": get_weather, "search_database": search_database \\}

@app.post("/mcp") async def mcp_endpoint(request: MCPRequest): if request.tool not in tools: raise HTTPException(status_code=400, detail=f"Tool '\\{request.tool\\}' not found")

try:
    result = await tools[request.tool](https://**request.parameters)
    return \\\\{"result": result\\\\}
except Exception as e:
    raise HTTPException(status_code=500, detail=str(e))

if name == "main": uvicorn.run(app, host="0.0.0.0", port=3000) ```_

Einsatz von Docker

```dockerfile

Dockerfile for Python MCP Server

FROM python:3.10-slim

WORKDIR /app

COPY requirements.txt . RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 3000

CMD ["uvicorn", "mcp_server:app", "--host", "0.0.0.0", "--port", "3000"] _yaml

docker-compose.yml

version: '3'

services: mcp-server: build: . ports: - "3000:3000" environment: - LOG_LEVEL=info - AUTH_ENABLED=true - AUTH_API_KEY=your-secret-api-key volumes: - ./config:/app/config ```_

Implementierung von Werkzeugen

Grundlegende Werkzeugstruktur

```javascript // JavaScript tool implementation const tools = \\{ // Simple tool with direct implementation get_current_time: async (params) => \\{ const \\{ timezone = 'UTC' \\} = params; return \\{ time: new Date().toLocaleString('en-US', \\{ timeZone: timezone \\}), timezone \\}; \\},

// Tool that calls an external API fetch_stock_price: async (params) => \\{ const \\{ symbol \\} = params; try \\{ const response = await fetch(https://api.example.com/stocks/$\\{symbol\\}); const data = await response.json(); return \\{ symbol, price: data.price, currency: data.currency, timestamp: data.timestamp \\}; \\} catch (error) \\{ throw new Error(Failed to fetch stock price: $\\{error.message\\}); \\} \\} \\}; _python

Python tool implementation

async def get_current_time(timezone: str = 'UTC') -> Dict[str, Any]: from datetime import datetime import pytz

tz = pytz.timezone(timezone)
current_time = datetime.now(tz)

return \\\\{
    "time": current_time.strftime("%Y-%m-%d %H:%M:%S"),
    "timezone": timezone
\\\\}

async def fetch_stock_price(symbol: str) -> Dict[str, Any]: import aiohttp

async with aiohttp.ClientSession() as session:
    async with session.get(f"https://api.example.com/stocks/\\\\{symbol\\\\}") as response:
        if response.status != 200:
            raise Exception(f"API returned status code \\\\{response.status\\\\}")

        data = await response.json()

        return \\\\{
            "symbol": symbol,
            "price": data["price"],
            "currency": data["currency"],
            "timestamp": data["timestamp"]
        \\\\}

```_

Tool-Making

json \\\\{ "tools": [ \\\\{ "name": "get_current_time", "description": "Get the current time in a specified timezone", "parameters": \\\\{ "type": "object", "properties": \\\\{ "timezone": \\\\{ "type": "string", "description": "Timezone identifier (e.g., 'UTC', 'America/New_York')" \\\\} \\\\}, "required": [] \\\\} \\\\}, \\\\{ "name": "fetch_stock_price", "description": "Get the current stock price for a given symbol", "parameters": \\\\{ "type": "object", "properties": \\\\{ "symbol": \\\\{ "type": "string", "description": "Stock symbol (e.g., 'AAPL', 'MSFT')" \\\\} \\\\}, "required": ["symbol"] \\\\} \\\\} ] \\\\}_

Advanced Tool mit Authentication

```javascript // Tool that requires authentication const authenticatedTools = \\{ get_user_data: async (params, context) => \\{ const \\{ userId \\} = params; const \\{ authToken \\} = context;

if (!authToken) \\\\{
  throw new Error('Authentication required');
\\\\}

try \\\\{
  const response = await fetch(`https://api.example.com/users/$\\{userId\\}`, \\\\{
    headers: \\\\{
      'Authorization': `Bearer $\\{authToken\\}`
    \\\\}
  \\\\});

  if (!response.ok) \\\\{
    throw new Error(`API returned status $\\{response.status\\}`);
  \\\\}

  return await response.json();
\\\\} catch (error) \\\\{
  throw new Error(`Failed to fetch user data: $\\{error.message\\}`);
\\\\}

\\} \\}; ```_

Authentifizierung und Sicherheit

API Schlüsselauthentifizierung

```javascript // Express middleware for API key authentication function apiKeyAuth(req, res, next) \\{ const apiKey = req.headers['x-api-key'];

| if (!apiKey | | apiKey !== process.env.MCP_API_KEY) \\{ | return res.status(401).json(\\{ error: 'Unauthorized' \\}); \\}

next(); \\}

// Apply middleware to MCP endpoint app.post('/mcp', apiKeyAuth, async (req, res) => \\{ // MCP request handling \\}); _python

FastAPI API key authentication

from fastapi import Depends, HTTPException, Security from fastapi.security.api_key import APIKeyHeader import os

API_KEY = os.getenv("MCP_API_KEY") api_key_header = APIKeyHeader(name="X-API-Key", auto_error=False)

async def get_api_key(api_key: str = Security(api_key_header)): if not api_key or api_key != API_KEY: raise HTTPException(status_code=401, detail="Invalid API Key") return api_key

@app.post("/mcp") async def mcp_endpoint(request: MCPRequest, api_key: str = Depends(get_api_key)): # MCP request handling ```_

JWT Authentication

```javascript // JWT authentication middleware const jwt = require('jsonwebtoken');

function jwtAuth(req, res, next) \\{ const authHeader = req.headers.authorization;

| if (!authHeader | | !authHeader.startsWith('Bearer ')) \\{ | return res.status(401).json(\\{ error: 'Unauthorized' \\}); \\}

const token = authHeader.split(' ')[1];

try \\{ const decoded = jwt.verify(token, process.env.JWT_SECRET); req.user = decoded; next(); \\} catch (error) \\{ return res.status(401).json(\\{ error: 'Invalid token' \\}); \\} \\}

// Apply middleware to MCP endpoint app.post('/mcp', jwtAuth, async (req, res) => \\{ // MCP request handling with access to req.user \\}); _python

FastAPI JWT authentication

from fastapi import Depends, HTTPException from fastapi.security import OAuth2PasswordBearer import jwt from jwt.exceptions import PyJWTError

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token") JWT_SECRET = os.getenv("JWT_SECRET")

async def get_current_user(token: str = Depends(oauth2_scheme)): try: payload = jwt.decode(token, JWT_SECRET, algorithms=["HS256"]) username = payload.get("sub") if username is None: raise HTTPException(status_code=401, detail="Invalid authentication credentials") except PyJWTError: raise HTTPException(status_code=401, detail="Invalid authentication credentials")

# Get user from database or return user info from token
return \\\\{"username": username\\\\}

@app.post("/mcp") async def mcp_endpoint(request: MCPRequest, current_user: dict = Depends(get_current_user)): # MCP request handling with access to current_user ```_

Grenzwerte

```javascript // Rate limiting middleware const rateLimit = require('express-rate-limit');

const mcpLimiter = rateLimit(\\{ windowMs: 15 * 60 * 1000, // 15 minutes max: 100, // limit each IP to 100 requests per windowMs message: 'Too many requests from this IP, please try again later' \\});

// Apply rate limiting to MCP endpoint app.post('/mcp', mcpLimiter, async (req, res) => \\{ // MCP request handling \\}); _python

FastAPI rate limiting with slowapi

from fastapi import Depends from slowapi import Limiter from slowapi.util import get_remote_address

limiter = Limiter(key_func=get_remote_address) app = FastAPI() app.state.limiter = limiter

@app.post("/mcp") @limiter.limit("100/minute") async def mcp_endpoint(request: MCPRequest, remote_addr: str = Depends(get_remote_address)): # MCP request handling ```_

Advanced MCP Server-Funktionen

Werkzeugentdeckung

```javascript // Endpoint for tool discovery app.get('/mcp/tools', apiKeyAuth, (req, res) => \\{ const toolManifest = \\{ tools: Object.keys(tools).map(toolName => \\{ return \\{ name: toolName, | description: toolDescriptions[toolName] | | '', | | parameters: toolParameters[toolName] | | \\{ type: 'object', properties: \\{\\} \\} | \\}; \\}) \\};

res.json(toolManifest); \\}); _python

FastAPI tool discovery endpoint

@app.get("/mcp/tools") async def get_tools(api_key: str = Depends(get_api_key)): tool_manifest = \\{ "tools": [ \\{ "name": name, "description": tool_descriptions.get(name, ""), "parameters": tool_parameters.get(name, \\{"type": "object", "properties": \\{\\}\\}) \\} for name in tools.keys() ] \\}

return tool_manifest

```_

Antworten zu optimieren

```javascript // Express streaming response app.post('/mcp/stream', apiKeyAuth, (req, res) => \\{ const \\{ tool, parameters \\} = req.body;

if (!streamingTools[tool]) \\{ return res.status(400).json(\\{ error: Streaming tool '$\\{tool\\}' not found \\}); \\}

// Set headers for streaming res.setHeader('Content-Type', 'text/event-stream'); res.setHeader('Cache-Control', 'no-cache'); res.setHeader('Connection', 'keep-alive');

// Create streaming tool instance const stream = streamingToolstool;

// Handle data events stream.on('data', (data) => \\{ res.write(data: $\\{JSON.stringify(data)\\}\n\n); \\});

// Handle end event stream.on('end', () => \\{ res.write('data: [DONE]\n\n'); res.end(); \\});

// Handle errors stream.on('error', (error) => \\{ res.write(data: $\\{JSON.stringify(\\{ error: error.message \\})\\}\n\n); res.end(); \\});

// Handle client disconnect req.on('close', () => \\{ stream.destroy(); \\}); \\}); _python

FastAPI streaming response

from fastapi import Response from fastapi.responses import StreamingResponse import json import asyncio

@app.post("/mcp/stream") async def stream_mcp(request: MCPRequest, api_key: str = Depends(get_api_key)): if request.tool not in streaming_tools: raise HTTPException(status_code=400, detail=f"Streaming tool '\\{request.tool\\}' not found")

async def event_generator():
    try:
        async for data in streaming_tools[request.tool](https://**request.parameters):
            yield f"data: \\\\{json.dumps(data)\\\\}\n\n"
            await asyncio.sleep(0.01)  # Small delay to prevent CPU hogging

        yield "data: [DONE]\n\n"
    except Exception as e:
        yield f"data: \\\\{json.dumps(\\\\{'error': str(e)\\\\})\\\\}\n\n"

return StreamingResponse(
    event_generator(),
    media_type="text/event-stream"
)

```_

Protokollierung und Überwachung

```javascript // Winston logger setup const winston = require('winston');

const logger = winston.createLogger(\\{ | level: process.env.LOG_LEVEL | | 'info', | format: winston.format.combine( winston.format.timestamp(), winston.format.json() ), transports: [ new winston.transports.Console(), new winston.transports.File(\\{ filename: 'mcp-server.log' \\}) ] \\});

// Logging middleware function loggingMiddleware(req, res, next) \\{ const start = Date.now();

// Log request logger.info(\\{ type: 'request', method: req.method, path: req.path, tool: req.body.tool, | requestId: req.headers['x-request-id'] | | uuidv4() | \\});

// Capture response const originalSend = res.send; res.send = function(body) \\{ const duration = Date.now() - start;

// Log response
logger.info(\\\\{
  type: 'response',
  method: req.method,
  path: req.path,
  statusCode: res.statusCode,
  duration,

| requestId: req.headers['x-request-id'] | | uuidv4() | \\});

return originalSend.call(this, body);

\\};

next(); \\}

// Apply logging middleware app.use(loggingMiddleware); _python

FastAPI logging middleware

import logging import time import uuid from fastapi import Request

logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', handlers=[ logging.FileHandler("mcp-server.log"), logging.StreamHandler() ] )

logger = logging.getLogger("mcp-server")

@app.middleware("http") async def logging_middleware(request: Request, call_next): request_id = request.headers.get("X-Request-ID", str(uuid.uuid4())) start_time = time.time()

# Log request
logger.info(\\\\{
    "type": "request",
    "method": request.method,
    "path": request.url.path,
    "request_id": request_id
\\\\})

# Process request
response = await call_next(request)

# Log response
duration = time.time() - start_time
logger.info(\\\\{
    "type": "response",
    "method": request.method,
    "path": request.url.path,
    "status_code": response.status_code,
    "duration": duration,
    "request_id": request_id
\\\\})

return response

```_

Fehlerbehebung

```javascript // Error handling middleware function errorHandler(err, req, res, next) \\{ logger.error(\\{ type: 'error', error: err.message, stack: err.stack, path: req.path, | requestId: req.headers['x-request-id'] | | uuidv4() | \\});

res.status(500).json(\\{ error: 'Internal server error', | requestId: req.headers['x-request-id'] | | uuidv4() | \\}); \\}

// Apply error handling middleware app.use(errorHandler); _python

FastAPI exception handlers

from fastapi.exceptions import RequestValidationError from starlette.exceptions import HTTPException as StarletteHTTPException

@app.exception_handler(RequestValidationError) async def validation_exception_handler(request: Request, exc: RequestValidationError): logger.error(\\{ "type": "validation_error", "path": request.url.path, "errors": exc.errors(), "request_id": request.headers.get("X-Request-ID", str(uuid.uuid4())) \\})

return JSONResponse(
    status_code=422,
    content=\\\\{"detail": exc.errors(), "type": "validation_error"\\\\}
)

@app.exception_handler(StarletteHTTPException) async def http_exception_handler(request: Request, exc: StarletteHTTPException): logger.error(\\{ "type": "http_error", "path": request.url.path, "status_code": exc.status_code, "detail": exc.detail, "request_id": request.headers.get("X-Request-ID", str(uuid.uuid4())) \\})

return JSONResponse(
    status_code=exc.status_code,
    content=\\\\{"detail": exc.detail, "type": "http_error"\\\\}
)

@app.exception_handler(Exception) async def general_exception_handler(request: Request, exc: Exception): logger.error(\\{ "type": "server_error", "path": request.url.path, "error": str(exc), "request_id": request.headers.get("X-Request-ID", str(uuid.uuid4())) \\})

return JSONResponse(
    status_code=500,
    content=\\\\{"detail": "Internal server error", "type": "server_error"\\\\}
)

```_

Cloud Bereitstellung

AWS Lambda Bereitstellung

```javascript // serverless.yml for AWS Lambda deployment service: mcp-server

provider: name: aws runtime: nodejs14.x region: us-east-1 environment: MCP_API_KEY: $\\{env:MCP_API_KEY\\} LOG_LEVEL: info

functions: mcp: handler: handler.mcp events: - http: path: mcp method: post cors: true toolDiscovery: handler: handler.toolDiscovery events: - http: path: mcp/tools method: get cors: true _javascript // handler.js for AWS Lambda const serverless = require('serverless-http'); const express = require('express'); const app = express();

// ... MCP server implementation ...

// Export Lambda handlers module.exports.mcp = serverless(app); module.exports.toolDiscovery = serverless(app); ```_

Azure Funktionen Bereitstellung

javascript // function.json for Azure Functions \\\\{ "bindings": [ \\\\{ "authLevel": "function", "type": "httpTrigger", "direction": "in", "name": "req", "methods": ["post"], "route": "mcp" \\\\}, \\\\{ "type": "http", "direction": "out", "name": "res" \\\\} ] \\\\}_ ```javascript // index.js for Azure Functions module.exports = async function (context, req) \\{ // Validate request | if (!req.body | | !req.body.tool) \\{ | context.res = \\{ status: 400, body: \\{ error: "Missing required fields" \\} \\}; return; \\}

const \\{ tool, parameters \\} = req.body;

// Validate API key const apiKey = req.headers['x-api-key']; | if (!apiKey | | apiKey !== process.env.MCP_API_KEY) \\{ | context.res = \\{ status: 401, body: \\{ error: "Unauthorized" \\} \\}; return; \\}

try \\{ // Execute tool if (!tools[tool]) \\{ context.res = \\{ status: 400, body: \\{ error: Tool '$\\{tool\\}' not found \\} \\}; return; \\}

const result = await tools[tool](parameters);

context.res = \\\\{
  status: 200,
  body: \\\\{ result \\\\}
\\\\};

\\} catch (error) \\{ context.log.error(Error executing tool $\\{tool\\}: $\\{error.message\\});

context.res = \\\\{
  status: 500,
  body: \\\\{ error: error.message \\\\}
\\\\};

\\} \\}; ```_

Kubernetes Bereitstellung

```yaml

kubernetes-deployment.yml

apiVersion: apps/v1 kind: Deployment metadata: name: mcp-server labels: app: mcp-server spec: replicas: 3 selector: matchLabels: app: mcp-server template: metadata: labels: app: mcp-server spec: containers: - name: mcp-server image: your-registry/mcp-server:latest ports: - containerPort: 3000 env: - name: MCP_API_KEY valueFrom: secretKeyRef: name: mcp-secrets key: api-key - name: LOG_LEVEL value: "info" resources: requests: memory: "128Mi" cpu: "100m" limits: memory: "256Mi" cpu: "200m" livenessProbe: httpGet: path: /health port: 3000 initialDelaySeconds: 30 periodSeconds: 10 readinessProbe: httpGet: path: /health port: 3000 initialDelaySeconds: 5 periodSeconds: 5

apiVersion: v1 kind: Service metadata: name: mcp-server-service spec: selector: app: mcp-server ports: - port: 80 targetPort: 3000 type: LoadBalancer

apiVersion: v1 kind: Secret metadata: name: mcp-secrets type: Opaque data: api-key: ```_

Integration mit KI-Modellen

OpenAI Integration

```javascript // Client-side integration with OpenAI const \\{ OpenAI \\} = require('openai');

const openai = new OpenAI(\\{ apiKey: process.env.OPENAI_API_KEY \\});

async function callOpenAIWithMCP(prompt, mcpServerUrl, mcpApiKey) \\{ const response = await openai.chat.completions.create(\\{ model: 'gpt-4', messages: [\\{ role: 'user', content: prompt \\}], tools: [ \\{ type: 'function', function: \\{ name: 'mcp_server', description: 'Call the MCP server to access external tools and data', parameters: \\{ type: 'object', properties: \\{ tool: \\{ type: 'string', description: 'The name of the tool to call' \\}, parameters: \\{ type: 'object', description: 'Parameters for the tool' \\} \\}, required: ['tool'] \\} \\} \\} ], tool_choice: 'auto' \\});

// Check if the model wants to call a tool const message = response.choices[0].message;

if (message.tool_calls && message.tool_calls.length > 0) \\{ const toolCall = message.tool_calls[0];

if (toolCall.function.name === 'mcp_server') \\\\{
  const \\\\{ tool, parameters \\\\} = JSON.parse(toolCall.function.arguments);

  // Call MCP server
  const mcpResponse = await fetch(mcpServerUrl, \\\\{
    method: 'POST',
    headers: \\\\{
      'Content-Type': 'application/json',
      'X-API-Key': mcpApiKey
    \\\\},
    body: JSON.stringify(\\\\{ tool, parameters \\\\})
  \\\\});

  const mcpResult = await mcpResponse.json();

  // Continue the conversation with the tool result
  const finalResponse = await openai.chat.completions.create(\\\\{
    model: 'gpt-4',
    messages: [
      \\\\{ role: 'user', content: prompt \\\\},
      message,
      \\\\{
        role: 'tool',
        tool_call_id: toolCall.id,
        content: JSON.stringify(mcpResult)
      \\\\}
    ]
  \\\\});

  return finalResponse.choices[0].message.content;
\\\\}

\\}

return message.content; \\} ```_

Anthropische Integration

```javascript // Client-side integration with Anthropic const \\{ Anthropic \\} = require('@anthropic-ai/sdk');

const anthropic = new Anthropic(\\{ apiKey: process.env.ANTHROPIC_API_KEY \\});

async function callAnthropicWithMCP(prompt, mcpServerUrl, mcpApiKey) \\{ const response = await anthropic.messages.create(\\{ model: 'claude-3-opus-20240229', messages: [\\{ role: 'user', content: prompt \\}], tools: [ \\{ name: 'mcp_server', description: 'Call the MCP server to access external tools and data', input_schema: \\{ type: 'object', properties: \\{ tool: \\{ type: 'string', description: 'The name of the tool to call' \\}, parameters: \\{ type: 'object', description: 'Parameters for the tool' \\} \\}, required: ['tool'] \\} \\} ] \\});

// Check if the model wants to call a tool const message = response.content[0];

if (message.type === 'tool_use' && message.name === 'mcp_server') \\{ const \\{ tool, parameters \\} = message.input;

// Call MCP server
const mcpResponse = await fetch(mcpServerUrl, \\\\{
  method: 'POST',
  headers: \\\\{
    'Content-Type': 'application/json',
    'X-API-Key': mcpApiKey
  \\\\},
  body: JSON.stringify(\\\\{ tool, parameters \\\\})
\\\\});

const mcpResult = await mcpResponse.json();

// Continue the conversation with the tool result
const finalResponse = await anthropic.messages.create(\\\\{
  model: 'claude-3-opus-20240229',
  messages: [
    \\\\{ role: 'user', content: prompt \\\\},
    \\\\{
      role: 'assistant',
      content: [message]
    \\\\},
    \\\\{
      role: 'tool',
      name: 'mcp_server',
      content: JSON.stringify(mcpResult)
    \\\\}
  ]
\\\\});

return finalResponse.content[0].text;

\\}

return message.text; \\} ```_

Best Practices

Sicherheit Best Practices

  • Authentication: Immer die richtige Authentifizierung für MCP-Server implementieren
  • Authorisierung: Implementierung feinkörniger Zugriffskontrolle für Werkzeuge
  • ** Eingangsvalidierung*: Gültig alle Eingabeparameter, um Injektionsangriffe zu verhindern
  • Rate Begrenzung: Implementierungssatz zur Verhinderung von Missbrauch
  • *Secrets Management: Verwenden Sie sichere Methoden zum Speichern und Zugriff auf API-Schlüssel und Geheimnisse
  • HTTPS: Verwenden Sie immer HTTPS für Produktionseinsätze
  • *Minimale Berechtigungen: Befolgen Sie das Prinzip der Mindestberechtigung für Werkzeugimplementierungen

Leistungsoptimierung

  • Caching: Implement-Caching für häufig verwendete Werkzeugergebnisse
  • ** Anschluss Pooling**: Verwenden Sie Verbindungspooling für Datenbank- und API-Verbindungen
  • *Asynchrone Verarbeitung: Verwenden Sie async/await für I/O-gebundene Operationen
  • *Horizontales Skalieren: Design für horizontale Skalierung zur Handhabung erhöhter Belastung
  • ** Timeout Handling*: Implementierung der richtigen Timeout-Handling für externe API-Anrufe
  • *Resource Limits: Setzen Sie entsprechende CPU- und Speicherlimits für Behälter

Zuverlässigkeit

  • Error Handling: Vollständige Fehlerbehandlung und Berichterstattung
  • *Retries: Retry-Logik für transiente Fehler hinzufügen
  • *Circuit Breakers: Implementieren von Leistungsschaltern für externe Abhängigkeiten
  • *Gesundheitsprüfung: Endpunkte für die Gesundheitsüberwachung hinzufügen
  • Logging: Implementieren Sie strukturiertes Protokoll zur Fehlerbehebung
  • Monitoring: Monitoring und Alarmierung für Schlüsselmetriken einrichten

Entwicklungs-Workflow

  • Version Control: Verwenden Sie die Versionssteuerung für MCP-Servercode
  • *CI/CD: Durchführung kontinuierlicher Integrations- und Bereitstellungspipelines
  • *Test: Schreibeinheit und Integrationstests für Werkzeuge
  • ** Aussprache**: Dokumentieren Sie alle Werkzeuge und ihre Parameter
  • Code Bewertungen: Durchführung gründlicher Code-Bewertungen für Sicherheit und Qualität
  • *Semantische Version: Verwenden semantische Versionierung für API-Änderungen

Fehlerbehebung

Gemeinsame Themen

Authentizitätsversagen

  • Cause: Falsche API-Schlüssel, abgelaufene Token oder falsch konfigurierte Authentifizierung
  • Lösung: Verifizieren API-Schlüssel, überprüfen Sie Token Ablauf und stellen Sie eine ordnungsgemäße Authentifizierung Konfiguration

Tool Execution Fehler

  • Cause: Ungültige Parameter, externe API-Fehler oder Fehler in der Werkzeugumsetzung
  • Lösung: Gültige Parameter, fügen Sie Fehlerbehandlung für externe APIs und Testwerkzeuge gründlich hinzu

Leistungsfragen

  • ** Denn**: Ineffiziente Werkzeugumsetzungen, fehlendes Caching oder Ressourcenzwänge
  • Solution: Optimieren Sie den Toolcode, implementieren Sie Cache und stellen Sie entsprechende Ressourcen zur Verfügung

Integrationsprobleme

  • Cause: Falsche Werkzeugschemata, fehlerhafte Parametertypen oder Protokollfehler
  • Solution: Verifizieren Sie Werkzeugschemas, stellen Sie sicher, dass Parametertypen übereinstimmen und folgen Sie der MCP-Spezifikation

--

*Diese umfassende MCP Server-Betrug-Blatt bietet alles, was nötig ist, um Model Context Protocol Server zu erstellen, einzusetzen und zu integrieren. Von grundlegender Einrichtung bis hin zu fortgeschrittenen Einsatzmustern nutzen Sie diese Beispiele und Best Practices, um leistungsstarke, standardisierte Verbindungen zwischen AI-Modellen und externen Tools und Dienstleistungen zu schaffen. *