Vývojářská příručka pro MCP servery
Naučte se, jak vytvořit a nasadit server Model Context Protocol (MCP) pro propojení AI modelů s externími nástroji a datovými zdroji. Krok za krokem pro začáteč...
14 min čtení
AI
Protocol
+4
Úvod
Model Context Protocol (MCP) představuje zásadní změnu v tom, jak systémy umělé inteligence komunikují s externími nástroji a zdroji dat. V kombinaci s výkonnými jazykovými modely OpenAI se MCP server stává bránou k inteligentní automatizaci, umožňuje AI systémům provádět složité operace, získávat data v reálném čase a bezproblémově se integrovat do vaší stávající infrastruktury. Tento komplexní průvodce vás provede celým procesem vývoje MCP serveru připojeného k OpenAI, od základních konceptů až po implementaci připravenou pro produkci.
Ať už stavíte platformu pro automatizaci zákaznické podpory, inteligentní systém pro zpracování dat nebo sofistikovaný business intelligence nástroj, pochopení architektury a implementace MCP serveru je zásadní pro moderní vývoj AI. Integrace MCP serverů a OpenAI vytváří silný ekosystém, kde AI modely dokáží analyzovat problémy, rozhodnout se, jaké nástroje využít, a přesně je spustit—při současném zachování bezpečnosti, spolehlivosti a škálovatelnosti.
Co je Model Context Protocol (MCP)?
Model Context Protocol je otevřený standard, který definuje, jak mohou AI modely objevovat a používat externí nástroje, služby a zdroje dat. Místo vkládání veškeré funkcionality přímo do AI modelu umožňuje MCP vývojářům vytvářet specializované servery, které zpřístupňují schopnosti přes standardizované rozhraní. Toto oddělení odpovědností přináší vyšší modularitu, bezpečnost a škálovatelnost AI aplikací.
V jádru MCP funguje na jednoduchém principu: AI model (například OpenAI GPT) vystupuje jako inteligentní orchestrátor, který chápe, jaké nástroje má k dispozici, kdy je použít a jak interpretovat jejich výsledky. MCP server poskytuje tyto nástroje, zpřístupňuje je přes dobře definované API, které AI model dokáže objevit a volat. Výsledkem je jasně definovaný kontrakt mezi AI systémem a vaší vlastní obchodní logikou.
Krása MCP spočívá v jeho flexibilitě. Server může nabízet nástroje pro cokoli—dotazy do databáze, API volání na služby třetích stran, zpracování souborů, výpočty nebo spouštění komplexních workflow. AI model se o těchto schopnostech dozví a inteligentně je zapojuje do konverzace, rozhoduje se, jaký nástroj spustit podle požadavku uživatele a kontextu dialogu.
Proč jsou MCP servery důležité pro moderní AI aplikace
Integrace MCP serverů s OpenAI řeší základní omezení velkých jazykových modelů: mají znalostní limit a nemohou přímo pracovat s daty v reálném čase nebo s proprietárními informacemi. Implementací MCP serveru rozšiřujete možnosti modelů OpenAI daleko za jejich základní trénink, umožníte jim přístup k aktuálním informacím, provádění obchodní logiky i integraci do vašich systémů.
Příklady, kde jsou MCP servery neocenitelné:
- Přístup k datům v reálném čase: AI asistent může dotazovat živé databáze, zjišťovat stav zásob, ověřovat informace o zákaznících nebo získávat aktuální tržní data—aniž by model znal detaily vaší databázové struktury.
- Automatizace obchodních procesů: Složitá workflow vyžadující více kroků, schválení nebo integrací může AI model orchestrálně řídit podle kontextu.
- Bezpečné získávání informací: Citlivá data nemusíte vkládat do promptů—MCP server požadavky ověří a vrátí jen to, co model pro daný úkol potřebuje.
- Optimalizace nákladů: Náročné výpočty přesouváte na MCP server, čímž snížíte spotřebu tokenů OpenAI API a tím i provozní náklady.
- Soulad a řízení: MCP servery umožňují auditování, maskování dat a řízení přístupů už na úrovni nástrojů, což pomáhá splnit regulatorní nároky.
Architektura přináší výhody i pro vývojářské týmy. Více týmů může nezávisle vyvíjet a spravovat své MCP servery, které pak skládáte do komplexních AI aplikací. Tento modulární přístup škáluje společně s růstem vaší organizace i komplexností AI řešení.
Porozumění architektuře: Jak MCP servery komunikují s OpenAI
Než se pustíte do implementace, je důležité pochopit architektonický tok, jak MCP server integruje OpenAI. Proces zahrnuje několik klíčových komponent:
AI model (OpenAI) zahajuje konverzace a rozhoduje, jaké nástroje spustit. Pokud vyhodnotí potřebu volání nástroje, vygeneruje strukturovaný požadavek s názvem nástroje a parametry.
MCP klient funguje jako překladač a prostředník. Přijímá požadavky na spuštění nástrojů od OpenAI, převádí je do formátu, který očekává váš MCP server, odesílá je správnému serveru a vrací výsledky zpět OpenAI v očekávaném formátu.
MCP server je vaše vlastní aplikace, která zpřístupňuje nástroje a schopnosti. Přijímá požadavky od MCP klienta, provádí požadované operace (dotazy do databáze, API volání, výpočty) a vrací strukturované výsledky.
Definice nástrojů představují kontrakty, které určují, jaké nástroje jsou k dispozici, jaké parametry přijímají a co vrací. Tyto definice objeví MCP klient a zaregistruje je u OpenAI, aby model věděl, co může využít.
Tato architektura zajišťuje jasné oddělení odpovědností: OpenAI řeší logiku a rozhodování, MCP server doménovou logiku a přístup k datům, MCP klient komunikační protokol mezi nimi.
Krok 1: Definujte MCP nástroje a jejich možnosti
Základem každého úspěšného MCP serveru je jasná definice nástrojů, které chcete zpřístupnit. Nejde jen o techniku—je to strategické rozhodnutí, jaké schopnosti váš AI systém potřebuje.
Začněte identifikací problémů, které má váš AI systém řešit. Potřebujete chatbota zákaznické podpory pro vyhledávání objednávek? Analytického asistenta pro dotazy do databáze? Nástroj na tvorbu obsahu s přístupem do znalostní báze? Každé použití bude mít jiné požadavky na nástroje.
Pro každý nástroj určete:
- Název nástroje: Jasný, výstižný identifikátor (např.
get_customer_order_history,search_knowledge_base,execute_sql_query) - Popis: Detailní vysvětlení, co nástroj dělá, psané srozumitelně pro AI model, aby věděl, kdy jej použít
- Vstupní parametry: Data potřebná pro fungování nástroje, včetně typů a validačních pravidel
- Výstupní formát: Struktura dat, která nástroj vrací
- Ošetření chyb: Jak nástroj komunikuje chyby či nestandardní situace
Příklad dobře definovaných specifikací nástrojů:
| Název nástroje | Účel | Vstupní parametry | Výstupní formát | Scénář použití |
|---|---|---|---|---|
get_customer_info | Získání detailů zákazníka | customer_id (string) | JSON objekt se jménem, e-mailem, stavem účtu | Dotazy zákaznické podpory |
search_orders | Vyhledání objednávek dle kritérií | customer_id, date_range, status | Pole objednávkových objektů | Historie a vyhledání objednávek |
create_support_ticket | Založení nového tiketu podpory | customer_id, issue_description, priority | Tiket s ID a potvrzením | Eskalace požadavků |
check_inventory | Zjištění dostupnosti produktu | product_id, warehouse_location | Stav skladu a detaily umístění | Dotazy na skladové zásoby |
process_refund | Zahájení refundace | order_id, amount, reason | Potvrzení transakce s referenčním číslem | Zpracování refundací |
Tento tabulkový přístup vám pomůže promyslet kompletní ekosystém nástrojů ještě před psaním kódu. Zajišťuje konzistenci, srozumitelnost a úplnost definic.
Krok 2: Nastavte si vývojové prostředí
Pro vytvoření MCP serveru potřebujete kvalitní vývojové zázemí. MCP servery lze stavět v různých jazycích, zde se zaměříme na nejpopulárnější varianty: TypeScript/Node.js a Python, protože mají nejvyspělejší MCP knihovny a komunitní podporu.
Pro vývoj v TypeScript/Node.js:
Vytvořte nový Node.js projekt a nainstalujte potřebné závislosti:
mkdir mcp-server-openai
cd mcp-server-openai
npm init -y
npm install @modelcontextprotocol/sdk openai dotenv express cors
npm install --save-dev typescript @types/node ts-node
Vytvořte soubor tsconfig.json pro konfiguraci TypeScriptu:
{
"compilerOptions": {
"target": "ES2020",
"module": "commonjs",
"lib": ["ES2020"],
"outDir": "./dist",
"rootDir": "./src",
"strict": true,
"esModuleInterop": true,
"skipLibCheck": true,
"forceConsistentCasingInFileNames": true
}
}
Pro vývoj v Pythonu:
Vytvořte virtuální prostředí a nainstalujte závislosti:
python -m venv venv
source venv/bin/activate # Ve Windows: venv\Scripts\activate
pip install mcp openai python-dotenv fastapi uvicorn
Nezávisle na zvoleném jazyce budete potřebovat:
- OpenAI API klíč: Zaregistrujte se na platform.openai.com a vygenerujte API klíč v nastavení účtu
- Konfigurace prostředí: Vytvořte soubor
.envpro bezpečné uložení citlivých údajů - Správa verzí: Inicializujte Git repozitář pro sledování vývoje
- Testovací framework: Nastavte si jednotkové testy pro ověření implementace nástrojů
Krok 3: Implementace jádra MCP serveru
Jádr MCP serveru tvoří aplikace, která zpřístupňuje vaše nástroje přes MCP protokol. To znamená vytvoření endpointů pro objevování a volání nástrojů.
Implementace v TypeScript/Node.js:
Vytvořte základní strukturu MCP serveru:
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
CallToolRequestSchema,
ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
const server = new Server({
name: "openai-mcp-server",
version: "1.0.0",
});
// Definujte nástroje
const tools = [
{
name: "get_customer_info",
description: "Získat informace o zákazníkovi podle ID",
inputSchema: {
type: "object",
properties: {
customer_id: {
type: "string",
description: "Jedinečný identifikátor zákazníka",
},
},
required: ["customer_id"],
},
},
// Přidejte další nástroje zde
];
// Odpověď na dotaz na seznam nástrojů
server.setRequestHandler(ListToolsRequestSchema, async () => {
return { tools };
});
// Odpověď na volání nástroje
server.setRequestHandler(CallToolRequestSchema, async (request) => {
const { name, arguments: args } = request.params;
if (name === "get_customer_info") {
// Implementace logiky nástroje
const customerId = args.customer_id;
// Dotaz do databáze nebo API
return {
content: [
{
type: "text",
text: JSON.stringify({
id: customerId,
name: "John Doe",
email: "john@example.com",
}),
},
],
};
}
return {
content: [{ type: "text", text: `Neznámý nástroj: ${name}` }],
isError: true,
};
});
// Spuštění serveru
const transport = new StdioServerTransport();
server.connect(transport);
Implementace v Pythonu:
from mcp.server import Server
from mcp.types import Tool, TextContent, ToolResult
import json
app = Server("openai-mcp-server")
# Definujte nástroje
TOOLS = [
Tool(
name="get_customer_info",
description="Získat informace o zákazníkovi podle ID",
inputSchema={
"type": "object",
"properties": {
"customer_id": {
"type": "string",
"description": "Jedinečný identifikátor zákazníka"
}
},
"required": ["customer_id"]
}
)
]
@app.list_tools()
async def list_tools():
return TOOLS
@app.call_tool()
async def call_tool(name: str, arguments: dict):
if name == "get_customer_info":
customer_id = arguments.get("customer_id")
# Logika nástroje
result = {
"id": customer_id,
"name": "John Doe",
"email": "john@example.com"
}
return ToolResult(
content=[TextContent(type="text", text=json.dumps(result))]
)
return ToolResult(
content=[TextContent(type="text", text=f"Neznámý nástroj: {name}")],
isError=True
)
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=8000)
Krok 4: Implementujte logiku nástrojů a napojení na byznys
Síla MCP serveru spočívá ve vlastní implementaci nástrojů. Zde napojujete databáze, voláte externí API, zpracováváte data či provádíte obchodní logiku.
Příklad napojení na databázi:
import { Pool } from "pg"; // Příklad pro PostgreSQL
const pool = new Pool({
connectionString: process.env.DATABASE_URL,
});
async function getCustomerInfo(customerId: string) {
try {
const result = await pool.query(
"SELECT id, name, email, account_status FROM customers WHERE id = $1",
[customerId]
);
if (result.rows.length === 0) {
return {
error: "Zákazník nenalezen",
status: 404,
};
}
return result.rows[0];
} catch (error) {
return {
error: "Chyba dotazu do databáze",
details: error.message,
status: 500,
};
}
}
Příklad napojení na externí API:
import axios from "axios";
async function searchExternalDatabase(query: string) {
try {
const response = await axios.get(
"https://api.external-service.com/search",
{
params: { q: query },
headers: {
Authorization: `Bearer ${process.env.EXTERNAL_API_KEY}`,
},
}
);
return response.data;
} catch (error) {
return {
error: "Chyba volání externího API",
details: error.message,
};
}
}
Ošetření chyb a validace:
Robustní ošetření chyb je zásadní pro produkční MCP servery. Implementujte důkladné validace a ošetření chyb:
function validateInput(args: any, schema: any): { valid: boolean; error?: string } {
// Validace povinných polí
for (const required of schema.required || []) {
if (!(required in args)) {
return { valid: false, error: `Chybí povinný parametr: ${required}` };
}
}
// Validace typů polí
for (const [key, property] of Object.entries(schema.properties || {})) {
if (key in args) {
const value = args[key];
const expectedType = (property as any).type;
if (typeof value !== expectedType) {
return {
valid: false,
error: `Parametr ${key} musí být typu ${expectedType}`,
};
}
}
}
return { valid: true };
}
Krok 5: Vytvořte MCP klienta pro integraci s OpenAI
MCP klient je most mezi OpenAI a vaším MCP serverem. Starají se o překlad mezi OpenAI function-calling formátem a protokolem vašeho MCP serveru.
TypeScript/Node.js MCP klient:
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
import OpenAI from "openai";
class MCPOpenAIBridge {
private mcpClient: Client;
private openaiClient: OpenAI;
private availableTools: any[] = [];
constructor() {
this.openaiClient = new OpenAI({
apiKey: process.env.OPENAI_API_KEY,
});
}
async initialize() {
// Připojení k MCP serveru
const transport = new StdioClientTransport({
command: "node",
args: ["dist/server.js"],
});
this.mcpClient = new Client({
name: "openai-mcp-client",
version: "1.0.0",
});
await this.mcpClient.connect(transport);
// Zjištění dostupných nástrojů
const toolsResponse = await this.mcpClient.listTools();
this.availableTools = toolsResponse.tools;
}
async executeWithOpenAI(userMessage: string) {
const messages = [{ role: "user" as const, content: userMessage }];
// Převod MCP nástrojů do OpenAI function formátu
const tools = this.availableTools.map((tool) => ({
type: "function" as const,
function: {
name: tool.name,
description: tool.description,
parameters: tool.inputSchema,
},
}));
let response = await this.openaiClient.chat.completions.create({
model: "gpt-4",
messages,
tools,
});
// Zpracování volání nástrojů v cyklu
while (response.choices[0].finish_reason === "tool_calls") {
const toolCalls = response.choices[0].message.tool_calls || [];
for (const toolCall of toolCalls) {
const toolName = toolCall.function.name;
const toolArgs = JSON.parse(toolCall.function.arguments);
// Spuštění nástroje na MCP serveru
const toolResult = await this.mcpClient.callTool({
name: toolName,
arguments: toolArgs,
});
// Přidání výsledku nástroje do zpráv
messages.push({
role: "assistant",
content: response.choices[0].message.content || "",
});
messages.push({
role: "tool",
content: JSON.stringify(toolResult),
tool_call_id: toolCall.id,
});
}
// Získání další odpovědi od OpenAI
response = await this.openaiClient.chat.completions.create({
model: "gpt-4",
messages,
tools,
});
}
return response.choices[0].message.content;
}
}
// Použití
const bridge = new MCPOpenAIBridge();
await bridge.initialize();
const result = await bridge.executeWithOpenAI(
"Jaká je historie objednávek zákazníka 12345?"
);
console.log(result);
Krok 6: Implementace bezpečnosti a autentizace
Bezpečnost je klíčová při stavbě MCP serverů, které pracují s citlivými daty a externími API. Implementujte víceúrovňové zabezpečení:
Správa API klíčů:
import crypto from "crypto";
class APIKeyManager {
private validKeys: Set<string> = new Set();
constructor() {
// Načtení platných API klíčů z prostředí nebo bezpečného úložiště
const keys = process.env.VALID_API_KEYS?.split(",") || [];
this.validKeys = new Set(keys);
}
validateRequest(apiKey: string): boolean {
return this.validKeys.has(apiKey);
}
generateNewKey(): string {
return crypto.randomBytes(32).toString("hex");
}
}
Podepisování a ověřování požadavků:
import crypto from "crypto";
function signRequest(payload: any, secret: string): string {
return crypto
.createHmac("sha256", secret)
.update(JSON.stringify(payload))
.digest("hex");
}
function verifySignature(payload: any, signature: string, secret: string): boolean {
const expectedSignature = signRequest(payload, secret);
return crypto.timingSafeEqual(
Buffer.from(signature),
Buffer.from(expectedSignature)
);
}
Omezení počtu požadavků:
import rateLimit from "express-rate-limit";
const limiter = rateLimit({
windowMs: 15 * 60 * 1000, // 15 minut
max: 100, // limit 100 požadavků na IP v okně
message: "Příliš mnoho požadavků z této IP, zkuste to prosím později.",
});
app.use("/api/", limiter);
Sanitizace vstupů:
function sanitizeInput(input: string): string {
// Odstranění potenciálně nebezpečných znaků
return input
.replace(/[<>]/g, "")
.trim()
.substring(0, 1000); // Limit délky
}
function validateCustomerId(customerId: string): boolean {
// Povolit pouze alfanumerické znaky a pomlčky
return /^[a-zA-Z0-9-]+$/.test(customerId);
}
Krok 7: Testování MCP serveru
Důkladné testování zajistí, že váš MCP server funguje správně a zvládá i okrajové případy.
Příklad jednotkových testů (Jest):
import { getCustomerInfo } from "../tools/customer";
describe("Zákaznické nástroje", () => {
test("vrací informace o zákazníkovi pro platné ID", async () => {
const result = await getCustomerInfo("cust_123");
expect(result).toHaveProperty("id");
expect(result).toHaveProperty("name");
expect(result).toHaveProperty("email");
});
test("vrací chybu pro neplatné ID", async () => {
const result = await getCustomerInfo("invalid");
expect(result).toHaveProperty("error");
});
test("zvládne chybu databáze elegantně", async () => {
// Mock database error
const result = await getCustomerInfo("cust_error");
expect(result).toHaveProperty("error");
expect(result.status).toBe(500);
});
});
Integrační testy:
describe("Integrace MCP serveru", () => {
let server: Server;
beforeAll(async () => {
server = new Server({ name: "test-server", version: "1.0.0" });
// Inicializace serveru
});
test("vrací všechny dostupné nástroje", async () => {
const tools = await server.listTools();
expect(tools.length).toBeGreaterThan(0);
expect(tools[0]).toHaveProperty("name");
expect(tools[0]).toHaveProperty("description");
});
test("spustí nástroj a vrátí výsledek", async () => {
const result = await server.callTool({
name: "get_customer_info",
arguments: { customer_id: "cust_123" },
});
expect(result).toBeDefined();
});
});
Využití FlowHunt pro vývoj a nasazení MCP serveru
FlowHunt nabízí komplexní platformu pro automatizaci celého životního cyklu vývoje, testování a nasazení MCP serverů. Místo ručního řízení každého kroku umožňuje FlowHunt vytvářet inteligentní automatizační workflow, které zvládnou opakující se úkoly a zajistí konzistenci v celém procesu.
Automatizované testování a ověřování:
FlowHunt může řídit váš testovací pipeline, spouštět jednotkové, integrační i end-to-end testy automaticky při každém commitu. Tím zajistíte, že nástroje vašeho MCP serveru fungují správně před nasazením do produkce.
Continuous Integration a Deployment:
Nastavte workflow ve FlowHunt tak, aby automaticky buildoval, testoval a nasazoval MCP server při každé změně v repozitáři. Omezíte tím manuální kroky a snížíte riziko lidské chyby.
Monitorování a upozorňování:
FlowHunt může monitorovat stav vašeho MCP serveru, sledovat časy odpovědí API a okamžitě vás upozornit na potíže. Pokud nějaký nástroj začne selhávat nebo se zhorší výkon, dozvíte se o tom včas.
Generování dokumentace:
Automaticky generujte API dokumentaci pro vaše MCP nástroje, aby byla vždy v souladu s implementací. Vývojáři tak mají vždy aktuální informace o dostupných nástrojích.
Optimalizace výkonu:
Analýzy FlowHunt pomohou odhalit úzká místa ve spouštění nástrojů. Uvidíte, které nástroje jsou nejčastěji volány, mají nejvyšší latenci a kde je vhodné optimalizovat.
Krok 8: Nasazení MCP serveru do produkce
Nasazení MCP serveru do produkce vyžaduje pečlivé plánování a provedení. Zvažte tyto strategie:
Docker kontejnerizace:
Vytvořte Dockerfile pro váš MCP server:
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY dist ./dist
EXPOSE 8000
CMD ["node", "dist/server.js"]
Build a push do registru:
docker build -t my-mcp-server:1.0.0 .
docker push myregistry.azurecr.io/my-mcp-server:1.0.0
Nasazení do Kubernetes:
Nasazení kontejnerizovaného MCP serveru do Kubernetes:
apiVersion: apps/v1
kind: Deployment
metadata:
name: mcp-server
spec:
replicas: 3
selector:
matchLabels:
app: mcp-server
template:
metadata:
labels:
app: mcp-server
spec:
containers:
- name: mcp-server
image: myregistry.azurecr.io/my-mcp-server:1.0.0
ports:
- containerPort: 8000
env:
- name: OPENAI_API_KEY
valueFrom:
secretKeyRef:
name: openai-secrets
key: api-key
- name: DATABASE_URL
valueFrom:
secretKeyRef:
name: db-secrets
key: connection-string
resources:
requests:
memory: "256Mi"
cpu: "250m"
limits:
memory: "512Mi"
cpu: "500m"
Konfigurace prostředí:
Používejte pro veškerou konfiguraci proměnné prostředí:
# .env.production
OPENAI_API_KEY=sk-...
DATABASE_URL=postgresql://user:pass@host:5432/db
MCP_SERVER_PORT=8000
LOG_LEVEL=info
ENABLE_METRICS=true
Pokročilé vzory a osvědčené postupy
Jak vaše MCP servery rostou, zvažte tyto pokročilé vzory:
Kompozice nástrojů:
Vytvářejte vyšší nástroje skládající více jednoduchých nástrojů:
async function processCustomerRefund(customerId: string, orderId: string, amount: number) {
// Získání info o zákazníkovi
const customer = await getCustomerInfo(customerId);
// Získání detailu objednávky
const order = await getOrderDetails(orderId);
// Ověření, že objednávka patří zákazníkovi
if (order.customerId !== customerId) {
throw new Error("Objednávka nepatří zákazníkovi");
}
// Zpracování refundace
const refund = await createRefund(orderId, amount);
// Odeslání notifikace
await sendNotification(customer.email, `Refundace ve výši $${amount} zpracována`);
return refund;
}
Strategie cachování:
Implementujte cache pro snížení latence a počtu API volání:
import NodeCache from "node-cache";
const cache = new NodeCache({ stdTTL: 600 }); // TTL 10 minut
async function getCustomerInfoWithCache(customerId: string) {
const cacheKey = `customer_${customerId}`;
// Nejprve kontrola cache
const cached = cache.get(cacheKey);
if (cached) {
return cached;
}
// Získání z databáze
const customer = await getCustomerInfo(customerId);
// Uložení do cache
cache.set(cacheKey, customer);
return customer;
}
Asynchronní zpracování úloh:
Pro dlouhotrvající operace implementujte asynchronní zpracování:
import Bull from "bull";
const jobQueue = new Bull("mcp-jobs");
jobQueue.process(async (job) => {
const { toolName, arguments: args } = job.data;
// Spuštění nástroje
const result = await executeTool(toolName, args);
return result;
});
async function executeToolAsync(toolName: string, args: any) {
const job = await jobQueue.add(
{ toolName, arguments: args },
{ attempts: 3, backoff: { type: "exponential", delay: 2000 } }
);
return job.id;
}
Monitorování, logování a observabilita
Produkční MCP servery vyžadují komplexní monitorování a logování:
Strukturované logování:
import winston from "winston";
const logger = winston.createLogger({
format: winston.format.json(),
transports: [
new winston.transports.File({
