Przewodnik rozwoju dla serwerów MCP
Dowiedz się, jak zbudować i wdrożyć serwer Model Context Protocol (MCP), aby połączyć modele AI z zewnętrznymi narzędziami i źródłami danych. Przewodnik krok po...
15 min czytania
AI
Protocol
+4
Wprowadzenie
Model Context Protocol (MCP) to przełom w sposobie, w jaki systemy sztucznej inteligencji współpracują z zewnętrznymi narzędziami i źródłami danych. Po połączeniu z zaawansowanymi modelami językowymi OpenAI, serwer MCP staje się bramą do inteligentnej automatyzacji, umożliwiając systemom AI wykonywanie złożonych operacji, pobieranie danych w czasie rzeczywistym oraz płynną integrację z istniejącą infrastrukturą. Ten kompleksowy przewodnik przeprowadzi Cię przez cały proces tworzenia serwera MCP łączącego się z OpenAI – od podstawowych koncepcji po wdrożenie na poziomie produkcyjnym.
Niezależnie od tego, czy budujesz platformę automatyzacji obsługi klienta, inteligentny system przetwarzania danych, czy rozbudowane narzędzie business intelligence, zrozumienie architektury i implementacji serwera MCP jest kluczowe dla współczesnego rozwoju AI. Integracja serwerów MCP z OpenAI tworzy potężny ekosystem, w którym modele AI potrafią rozumować nad problemami, decydować, z jakich narzędzi skorzystać, oraz precyzyjnie je wykonywać—wszystko przy zachowaniu bezpieczeństwa, niezawodności i skalowalności.
Czym jest Model Context Protocol (MCP)?
Model Context Protocol to otwarty standard definiujący, jak modele AI mogą wykrywać i wykorzystywać zewnętrzne narzędzia, usługi i źródła danych. Zamiast osadzać całą funkcjonalność bezpośrednio w modelu AI, MCP pozwala deweloperom tworzyć wyspecjalizowane serwery udostępniające możliwości przez standaryzowany interfejs. To rozdzielenie odpowiedzialności zapewnia lepszą modułowość, bezpieczeństwo i skalowalność aplikacji AI.
U podstaw MCP leży prosta zasada: model AI (w tym przypadku GPT od OpenAI) działa jako inteligentny orkiestrator, który rozumie dostępne narzędzia, decyduje, kiedy z nich skorzystać, i interpretuje ich wyniki. Serwer MCP pełni rolę dostawcy tych narzędzi, udostępniając je przez dobrze zdefiniowane API, które model AI może odkryć i wywołać. W ten sposób powstaje przejrzysty kontrakt pomiędzy systemem AI a Twoją logiką biznesową.
Piękno MCP tkwi w jego elastyczności. Twój serwer może udostępniać narzędzia do wszystkiego—zapytania do bazy danych, wywołania API do usług zewnętrznych, przetwarzanie plików, obliczenia czy nawet uruchamianie złożonych procesów. Model AI poznaje te możliwości i inteligentnie korzysta z nich w ramach rozmów, podejmując decyzje, jakie narzędzia wywołać na podstawie żądania użytkownika i kontekstu rozmowy.
Dlaczego serwery MCP są ważne dla współczesnych aplikacji AI
Integracja serwerów MCP z OpenAI rozwiązuje podstawowe ograniczenie dużych modeli językowych: mają one limit wiedzy i nie mogą bezpośrednio współdziałać z systemami czasu rzeczywistego ani zastrzeżonymi danymi. Dzięki wdrożeniu serwera MCP rozszerzasz możliwości modeli OpenAI daleko poza ich bazowy trening, umożliwiając dostęp do aktualnych informacji, wykonywanie logiki biznesowej i integrację z istniejącymi systemami.
Oto praktyczne scenariusze, w których serwery MCP okazują się nieocenione:
- Dostęp do danych w czasie rzeczywistym: Twój asystent AI może zapytać o aktualny stan magazynowy, sprawdzić dane klienta, pozyskać bieżące dane rynkowe—wszystko bez konieczności znajomości szczegółów Twojej bazy danych przez model AI.
- Automatyzacja procesów biznesowych: Złożone procesy wymagające kilku kroków, akceptacji lub integracji mogą być orkiestrą przez model AI, który decyduje o kolejności działań w zależności od kontekstu.
- Bezpieczne pobieranie informacji: Zamiast umieszczać w promptach wrażliwe dane, Twój serwer MCP może autoryzować zapytania i udostępniać tylko te informacje, które są potrzebne do wykonania zadania.
- Optymalizacja kosztów: Przenosząc obciążające obliczeniowo zadania na swój serwer MCP, obniżasz zużycie tokenów w API OpenAI, co bezpośrednio przekłada się na niższe koszty operacyjne.
- Zgodność i governance: Serwery MCP pozwalają wdrożyć audyt, maskowanie danych i kontrolę dostępu na poziomie narzędzi, co ułatwia spełnianie wymogów regulacyjnych.
Taka architektura przynosi również korzyści zespołom deweloperskim. Różne zespoły mogą niezależnie rozwijać i utrzymywać własne serwery MCP, które razem tworzą rozbudowane aplikacje AI. Podejście modułowe dobrze się skaluje wraz z rozwojem organizacji i wzrostem złożoności rozwiązań AI.
Zrozumienie architektury: jak serwery MCP łączą się z OpenAI
Zanim przejdziesz do implementacji, kluczowe jest zrozumienie przepływu architektonicznego integracji serwera MCP z OpenAI. Proces obejmuje kilka kluczowych komponentów współpracujących ze sobą:
Model AI (OpenAI) inicjuje konwersacje i decyduje, które narzędzia wywołać. Gdy model uzna, że należy wywołać narzędzie, generuje uporządkowane żądanie zawierające nazwę narzędzia i parametry.
Klient MCP działa jako tłumacz i pośrednik. Odbiera żądania wywołania narzędzi od OpenAI, tłumaczy je na format oczekiwany przez Twój serwer MCP, wysyła żądanie do odpowiedniego serwera i zwraca wynik do OpenAI w formacie, którego model oczekuje.
Serwer MCP to Twoja własna aplikacja udostępniająca narzędzia i możliwości. Odbiera żądania od klienta MCP, wykonuje żądane operacje (np. zapytania do bazy, wywołania API czy złożone obliczenia) i zwraca uporządkowane wyniki.
Definicje narzędzi to kontrakty określające, jakie narzędzia są dostępne, jakie przyjmują parametry oraz co zwracają. Klient MCP wykrywa te definicje i rejestruje w OpenAI, aby model wiedział, co może wykorzystać.
Taka architektura zapewnia przejrzysty podział odpowiedzialności: OpenAI odpowiada za rozumowanie i decyzje, Twój serwer MCP za logikę domenową i dostęp do danych, a klient MCP za komunikację między nimi.
Krok 1: Zdefiniuj narzędzia i możliwości MCP
Podstawą każdego skutecznego serwera MCP jest jasna definicja narzędzi, które chcesz udostępnić. To nie tylko techniczny etap—decydujesz strategicznie, jakie możliwości są potrzebne Twojemu systemowi AI, by osiągnąć cele.
Zacznij od zidentyfikowania konkretnych problemów, które Twój system AI ma rozwiązywać. Czy budujesz czatbota obsługi klienta, który musi wyszukiwać zamówienia? Asystenta do analizy danych przeszukującego bazy? Narzędzie do tworzenia treści z dostępem do firmowej bazy wiedzy? Każdy przypadek będzie wymagał innych narzędzi.
Dla każdego narzędzia zdefiniuj:
- Nazwa narzędzia: jasny, opisowy identyfikator (np.
get_customer_order_history,search_knowledge_base,execute_sql_query) - Opis: szczegółowy opis działania narzędzia, napisany językiem naturalnym, by model AI wiedział, kiedy z niego skorzystać
- Parametry wejściowe: dane wymagane do działania narzędzia, w tym typy i reguły walidacji
- Format wyjścia: struktura danych zwracanych przez narzędzie
- Obsługa błędów: sposób komunikowania niepowodzeń lub sytuacji brzegowych
Przykład dobrze zdefiniowanych specyfikacji narzędzi:
| Nazwa narzędzia | Cel | Parametry wejściowe | Format wyjścia | Przypadek użycia |
|---|---|---|---|---|
get_customer_info | Pobierz dane klienta | customer_id (string) | Obiekt JSON: imię, email, status konta | Zapytania obsługi klienta |
search_orders | Znajdź zamówienia | customer_id, date_range, status | Tablica obiektów zamówień | Historia zamówień |
create_support_ticket | Utwórz zgłoszenie wsparcia | customer_id, issue_description, priority | Obiekt zgłoszenia z ID i potwierdzeniem | Eskalacja problemu |
check_inventory | Sprawdź dostępność produktu | product_id, warehouse_location | Liczba i lokalizacja produktu | Zapytania o stan magazynu |
process_refund | Zainicjuj zwrot | order_id, amount, reason | Potwierdzenie transakcji z numerem referencyjnym | Przetwarzanie zwrotów |
Takie podejście tabelaryczne pozwala przemyśleć cały ekosystem narzędzi przed rozpoczęciem kodowania i zapewnia spójność oraz kompletność definicji.
Krok 2: Przygotuj środowisko deweloperskie
Tworzenie serwera MCP wymaga solidnych podstaw deweloperskich. Choć serwery MCP można pisać w wielu językach, skupiamy się na najpopularniejszych: TypeScript/Node.js oraz Python, bo mają najbardziej rozwinięte biblioteki MCP i wsparcie społeczności.
Dla TypeScript/Node.js:
Utwórz nowy projekt Node.js i zainstaluj zależności:
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
Utwórz plik tsconfig.json:
{
"compilerOptions": {
"target": "ES2020",
"module": "commonjs",
"lib": ["ES2020"],
"outDir": "./dist",
"rootDir": "./src",
"strict": true,
"esModuleInterop": true,
"skipLibCheck": true,
"forceConsistentCasingInFileNames": true
}
}
Dla Pythona:
Utwórz środowisko wirtualne i zainstaluj zależności:
python -m venv venv
source venv/bin/activate # Na Windows: venv\Scripts\activate
pip install mcp openai python-dotenv fastapi uvicorn
Niezależnie od języka potrzebujesz:
- Klucz API OpenAI: Zarejestruj się na platform.openai.com i wygeneruj klucz API w ustawieniach konta
- Konfiguracja środowiska: Utwórz plik
.envdo bezpiecznego przechowywania poufnych danych - Kontrola wersji: Zainicjuj repozytorium Git, by śledzić rozwój projektu
- Framework testowy: Skonfiguruj testy jednostkowe dla walidacji narzędzi
Krok 3: Implementacja rdzenia serwera MCP
Rdzeniem serwera MCP jest aplikacja udostępniająca narzędzia przez protokół MCP. Obejmuje to tworzenie endpointów do wykrywania narzędzi oraz ich wykonywania.
Implementacja TypeScript/Node.js:
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",
});
// Definicja narzędzi
const tools = [
{
name: "get_customer_info",
description: "Pobierz informacje o kliencie na podstawie ID",
inputSchema: {
type: "object",
properties: {
customer_id: {
type: "string",
description: "Unikalny identyfikator klienta",
},
},
required: ["customer_id"],
},
},
// Dodaj kolejne narzędzia tu
];
// Obsługa żądania listy narzędzi
server.setRequestHandler(ListToolsRequestSchema, async () => {
return { tools };
});
// Obsługa wywołań narzędzi
server.setRequestHandler(CallToolRequestSchema, async (request) => {
const { name, arguments: args } = request.params;
if (name === "get_customer_info") {
// Logika narzędzia
const customerId = args.customer_id;
// Pobierz dane z bazy lub API
return {
content: [
{
type: "text",
text: JSON.stringify({
id: customerId,
name: "Jan Kowalski",
email: "jan@example.com",
}),
},
],
};
}
return {
content: [{ type: "text", text: `Nieznane narzędzie: ${name}` }],
isError: true,
};
});
// Uruchomienie serwera
const transport = new StdioServerTransport();
server.connect(transport);
Implementacja Python:
from mcp.server import Server
from mcp.types import Tool, TextContent, ToolResult
import json
app = Server("openai-mcp-server")
# Definicja narzędzi
TOOLS = [
Tool(
name="get_customer_info",
description="Pobierz informacje o kliencie na podstawie ID",
inputSchema={
"type": "object",
"properties": {
"customer_id": {
"type": "string",
"description": "Unikalny identyfikator klienta"
}
},
"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 narzędzia
result = {
"id": customer_id,
"name": "Jan Kowalski",
"email": "jan@example.com"
}
return ToolResult(
content=[TextContent(type="text", text=json.dumps(result))]
)
return ToolResult(
content=[TextContent(type="text", text=f"Nieznane narzędzie: {name}")],
isError=True
)
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=8000)
Krok 4: Implementacja logiki narzędzi i integracji biznesowej
Prawdziwa siła serwera MCP tkwi w implementacji narzędzi—tu łączysz się z bazami danych, wywołujesz zewnętrzne API, przetwarzasz dane i realizujesz logikę biznesową.
Przykład integracji z bazą danych:
import { Pool } from "pg"; // Przykład dla 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: "Nie znaleziono klienta",
status: 404,
};
}
return result.rows[0];
} catch (error) {
return {
error: "Błąd zapytania do bazy",
details: error.message,
status: 500,
};
}
}
Przykład integracji z zewnętrznym 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: "Błąd wywołania zewnętrznego API",
details: error.message,
};
}
}
Obsługa błędów i walidacja:
Solidna obsługa błędów to podstawa produkcyjnych serwerów MCP. Wdróż walidację i obsługę wyjątków:
function validateInput(args: any, schema: any): { valid: boolean; error?: string } {
// Walidacja pól wymaganych
for (const required of schema.required || []) {
if (!(required in args)) {
return { valid: false, error: `Brak wymaganego parametru: ${required}` };
}
}
// Walidacja typów
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} musi być typu ${expectedType}`,
};
}
}
}
return { valid: true };
}
Krok 5: Stwórz klienta MCP do integracji z OpenAI
Klient MCP to most pomiędzy OpenAI a Twoim serwerem MCP. Odpowiada za tłumaczenie między formatem funkcji OpenAI a protokołem Twojego serwera MCP.
TypeScript/Node.js Klient MCP:
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() {
// Połącz z serwerem MCP
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);
// Odkryj dostępne narzędzia
const toolsResponse = await this.mcpClient.listTools();
this.availableTools = toolsResponse.tools;
}
async executeWithOpenAI(userMessage: string) {
const messages = [{ role: "user" as const, content: userMessage }];
// Konwersja narzędzi MCP do formatu funkcji OpenAI
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,
});
// Obsługa wywołań narzędzi w pętli
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);
// Wykonaj narzędzie na serwerze MCP
const toolResult = await this.mcpClient.callTool({
name: toolName,
arguments: toolArgs,
});
// Dodaj wynik narzędzia do wiadomości
messages.push({
role: "assistant",
content: response.choices[0].message.content || "",
});
messages.push({
role: "tool",
content: JSON.stringify(toolResult),
tool_call_id: toolCall.id,
});
}
// Pobierz kolejną odpowiedź z OpenAI
response = await this.openaiClient.chat.completions.create({
model: "gpt-4",
messages,
tools,
});
}
return response.choices[0].message.content;
}
}
// Użycie
const bridge = new MCPOpenAIBridge();
await bridge.initialize();
const result = await bridge.executeWithOpenAI(
"Jaka jest historia zamówień klienta 12345?"
);
console.log(result);
Krok 6: Zaimplementuj bezpieczeństwo i uwierzytelnianie
Bezpieczeństwo jest kluczowe przy budowie serwerów MCP współpracujących z wrażliwymi danymi i zewnętrznymi API. Wdróż wielowarstwowe zabezpieczenia:
Zarządzanie kluczami API:
import crypto from "crypto";
class APIKeyManager {
private validKeys: Set<string> = new Set();
constructor() {
// Załaduj poprawne klucze API ze środowiska lub bezpiecznego przechowywania
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");
}
}
Podpisywanie i weryfikacja żądań:
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)
);
}
Limitowanie zapytań:
import rateLimit from "express-rate-limit";
const limiter = rateLimit({
windowMs: 15 * 60 * 1000, // 15 minut
max: 100, // limit 100 żądań na IP w oknie czasowym
message: "Za dużo zapytań z tego adresu IP, spróbuj ponownie później.",
});
app.use("/api/", limiter);
Sanityzacja wejścia:
function sanitizeInput(input: string): string {
// Usuń potencjalnie niebezpieczne znaki
return input
.replace(/[<>]/g, "")
.trim()
.substring(0, 1000); // Ogranicz długość
}
function validateCustomerId(customerId: string): boolean {
// Dozwolone tylko znaki alfanumeryczne i myślniki
return /^[a-zA-Z0-9-]+$/.test(customerId);
}
Krok 7: Testowanie serwera MCP
Kompleksowe testy zapewniają poprawność działania serwera MCP i obsługę nietypowych przypadków.
Przykład testów jednostkowych (Jest):
import { getCustomerInfo } from "../tools/customer";
describe("Narzędzia klienta", () => {
test("powinno zwrócić dane klienta dla poprawnego ID", async () => {
const result = await getCustomerInfo("cust_123");
expect(result).toHaveProperty("id");
expect(result).toHaveProperty("name");
expect(result).toHaveProperty("email");
});
test("powinno zwrócić błąd dla nieprawidłowego ID", async () => {
const result = await getCustomerInfo("invalid");
expect(result).toHaveProperty("error");
});
test("powinno obsłużyć błąd bazy danych", async () => {
// Mock błędu bazy
const result = await getCustomerInfo("cust_error");
expect(result).toHaveProperty("error");
expect(result.status).toBe(500);
});
});
Testy integracyjne:
describe("Integracja serwera MCP", () => {
let server: Server;
beforeAll(async () => {
server = new Server({ name: "test-server", version: "1.0.0" });
// Inicjalizacja serwera
});
test("powinno zwrócić listę narzędzi", async () => {
const tools = await server.listTools();
expect(tools.length).toBeGreaterThan(0);
expect(tools[0]).toHaveProperty("name");
expect(tools[0]).toHaveProperty("description");
});
test("powinno wykonać narzędzie i zwrócić wynik", async () => {
const result = await server.callTool({
name: "get_customer_info",
arguments: { customer_id: "cust_123" },
});
expect(result).toBeDefined();
});
});
Wykorzystanie FlowHunt do rozwoju i wdrażania serwera MCP
FlowHunt to kompleksowa platforma do automatyzacji całego cyklu życia serwera MCP—od rozwoju przez testy po wdrożenie. Zamiast ręcznie zarządzać każdym etapem, FlowHunt pozwala tworzyć inteligentne przepływy automatyzujące powtarzalne czynności i zapewniające spójność procesu.
Automatyczne testowanie i walidacja:
FlowHunt może automatyzować pipeline testów jednostkowych, integracyjnych i end-to-end przy każdym commicie. Gwarantuje to, że narzędzia Twojego serwera MCP zawsze działają poprawnie przed wdrożeniem na produkcję.
Ciągła integracja i wdrożenia:
Skonfiguruj FlowHunt tak, by automatycznie budował, testował i wdrażał serwer MCP po każdym pushu do repozytorium. Eliminuje to ręczne kroki i minimalizuje ryzyko błędów.
Monitoring i alerty:
FlowHunt monitoruje zdrowie serwera MCP, śledzi czasy odpowiedzi API i powiadamia o problemach. Jeśli narzędzie przestanie działać lub spadnie wydajność—otrzymasz natychmiastowe powiadomienie.
Generowanie dokumentacji:
Automatycznie twórz dokumentację API narzędzi serwera MCP, utrzymując ją w zgodności z rzeczywistą implementacją. Deweloperzy zawsze mają dostęp do aktualnych informacji.
Optymalizacja wydajności:
Analityka FlowHunt pozwala identyfikować wąskie gardła w narzędziach. Widzisz, które narzędzia są najczęściej wywoływane, mają największe opóźnienia i gdzie warto optymalizować.
Krok 8: Wdrażanie serwera MCP na produkcję
Wdrożenie serwera MCP na produkcję wymaga planowania. Oto strategie wdrożenia:
Konteneryzacja Docker:
Przykładowy Dockerfile:
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY dist ./dist
EXPOSE 8000
CMD ["node", "dist/server.js"]
Buduj i wypychaj do rejestru kontenerów:
docker build -t my-mcp-server:1.0.0 .
docker push myregistry.azurecr.io/my-mcp-server:1.0.0
Wdrożenie na 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"
Konfiguracja środowiska:
Używaj zmiennych środowiskowych:
# .env.production
OPENAI_API_KEY=sk-...
DATABASE_URL=postgresql://user:pass@host:5432/db
MCP_SERVER_PORT=8000
LOG_LEVEL=info
ENABLE_METRICS=true
Zaawansowane wzorce i dobre praktyki
Gdy Twój serwer MCP rośnie, rozważ poniższe rozwiązania:
Kompozycja narzędzi:
Twórz narzędzia wyższego poziomu łączące kilka prostszych narzędzi:
async function processCustomerRefund(customerId: string, orderId: string, amount: number) {
// Pobierz dane klienta
const customer = await getCustomerInfo(customerId);
// Pobierz szczegóły zamówienia
const order = await getOrderDetails(orderId);
// Weryfikuj przynależność zamówienia
if (order.customerId !== customerId) {
throw new Error("Zamówienie nie należy do klienta");
}
// Przetwórz zwrot
const refund = await createRefund(orderId, amount);
// Wyślij powiadomienie
await sendNotification(customer.email, `Zwrot ${amount} zł został przetworzony`);
return refund;
}
Strategia cache’owania:
Wdróż cache, by zmniejszyć opóźnienia i liczbę wywołań API:
import NodeCache from "node-cache";
const cache = new NodeCache({ stdTTL: 600 }); // 10 minut
async function getCustomerInfoWithCache(customerId: string) {
const cacheKey = `customer_${customerId}`;
// Najpierw sprawdź cache
const cached = cache.get(cacheKey);
if (cached) {
return cached;
}
// Pobierz z bazy
const customer = await getCustomerInfo(customerId);
// Zapisz w cache
cache.set(cacheKey, customer);
return customer;
}
Asynchroniczne przetwarzanie zadań:
Dla zadań długotrwałych—kolejkowanie:
import Bull from "bull";
const jobQueue = new Bull("m
