Construirea unui server MCP care se conectează la OpenAI: Ghid complet pentru dezvoltatori

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

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "lib": ["ES2020"],
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  }
}

python -m venv venv
source venv/bin/activate  # Pe Windows: venv\Scripts\activate
pip install mcp openai python-dotenv fastapi uvicorn

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",
});

// Definește instrumentele tale
const tools = [
  {
    name: "get_customer_info",
    description: "Recuperează informații despre client după ID",
    inputSchema: {
      type: "object",
      properties: {
        customer_id: {
          type: "string",
          description: "Identificatorul unic al clientului",
        },
      },
      required: ["customer_id"],
    },
  },
  // Adaugă mai multe instrumente aici
];

// Gestionează cererile de listare a instrumentelor
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return { tools };
});

// Gestionează cererile de execuție a instrumentelor
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  if (name === "get_customer_info") {
    // Implementează logica instrumentului aici
    const customerId = args.customer_id;
    // Interoghează baza de date sau API-ul tău
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify({
            id: customerId,
            name: "John Doe",
            email: "john@example.com",
          }),
        },
      ],
    };
  }

  return {
    content: [{ type: "text", text: `Instrument necunoscut: ${name}` }],
    isError: true,
  };
});

// Pornește serverul
const transport = new StdioServerTransport();
server.connect(transport);

from mcp.server import Server
from mcp.types import Tool, TextContent, ToolResult
import json

app = Server("openai-mcp-server")

# Definește instrumentele
TOOLS = [
    Tool(
        name="get_customer_info",
        description="Recuperează informații despre client după ID",
        inputSchema={
            "type": "object",
            "properties": {
                "customer_id": {
                    "type": "string",
                    "description": "Identificatorul unic al clientului"
                }
            },
            "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")
        # Implementează logica instrumentului
        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"Instrument necunoscut: {name}")],
        isError=True
    )

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

import { Pool } from "pg"; // Exemplu 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: "Clientul nu a fost găsit",
        status: 404,
      };
    }

    return result.rows[0];
  } catch (error) {
    return {
      error: "Interogarea bazei de date a eșuat",
      details: error.message,
      status: 500,
    };
  }
}

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: "Apelul către API-ul extern a eșuat",
      details: error.message,
    };
  }
}

function validateInput(args: any, schema: any): { valid: boolean; error?: string } {
  // Validare câmpuri obligatorii
  for (const required of schema.required || []) {
    if (!(required in args)) {
      return { valid: false, error: `Parametru obligatoriu lipsă: ${required}` };
    }
  }

  // Validare tipuri de câmpuri
  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: `Parametrul ${key} trebuie să fie de tip ${expectedType}`,
        };
      }
    }
  }

  return { valid: true };
}

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() {
    // Conectare la serverul 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);

    // Descoperă instrumentele disponibile
    const toolsResponse = await this.mcpClient.listTools();
    this.availableTools = toolsResponse.tools;
  }

  async executeWithOpenAI(userMessage: string) {
    const messages = [{ role: "user" as const, content: userMessage }];

    // Conversie instrumente MCP în format de funcție 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,
    });

    // Gestionare apeluri de instrumente într-o buclă
    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);

        // Execută instrumentul pe serverul MCP
        const toolResult = await this.mcpClient.callTool({
          name: toolName,
          arguments: toolArgs,
        });

        // Adaugă rezultatul instrumentului la mesaje
        messages.push({
          role: "assistant",
          content: response.choices[0].message.content || "",
        });

        messages.push({
          role: "tool",
          content: JSON.stringify(toolResult),
          tool_call_id: toolCall.id,
        });
      }

      // Obține următorul răspuns de la OpenAI
      response = await this.openaiClient.chat.completions.create({
        model: "gpt-4",
        messages,
        tools,
      });
    }

    return response.choices[0].message.content;
  }
}

// Utilizare
const bridge = new MCPOpenAIBridge();
await bridge.initialize();
const result = await bridge.executeWithOpenAI(
  "Care este istoricul comenzilor pentru clientul 12345?"
);
console.log(result);

import crypto from "crypto";

class APIKeyManager {
  private validKeys: Set<string> = new Set();

  constructor() {
    // Încarcă cheile API valide din mediu sau stocare securizată
    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");
  }
}

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)
  );
}

import rateLimit from "express-rate-limit";

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minute
  max: 100, // max 100 cereri per IP per fereastră
  message: "Prea multe cereri de la acest IP, te rugăm să încerci mai târziu.",
});

app.use("/api/", limiter);

function sanitizeInput(input: string): string {
  // Elimină caracterele potențial periculoase
  return input
    .replace(/[<>]/g, "")
    .trim()
    .substring(0, 1000); // Limitează lungimea
}

function validateCustomerId(customerId: string): boolean {
  // Permite doar alfanumeric și cratimă
  return /^[a-zA-Z0-9-]+$/.test(customerId);
}

import { getCustomerInfo } from "../tools/customer";

describe("Instrumente client", () => {
  test("ar trebui să returneze info client pentru ID valid", async () => {
    const result = await getCustomerInfo("cust_123");
    expect(result).toHaveProperty("id");
    expect(result).toHaveProperty("name");
    expect(result).toHaveProperty("email");
  });

  test("ar trebui să returneze eroare pentru ID invalid", async () => {
    const result = await getCustomerInfo("invalid");
    expect(result).toHaveProperty("error");
  });

  test("ar trebui să gestioneze elegant erorile de bază de date", async () => {
    // Mock eroare db
    const result = await getCustomerInfo("cust_error");
    expect(result).toHaveProperty("error");
    expect(result.status).toBe(500);
  });
});

describe("Integrare server MCP", () => {
  let server: Server;

  beforeAll(async () => {
    server = new Server({ name: "test-server", version: "1.0.0" });
    // Inițializează serverul
  });

  test("ar trebui să listeze toate instrumentele disponibile", async () => {
    const tools = await server.listTools();
    expect(tools.length).toBeGreaterThan(0);
    expect(tools[0]).toHaveProperty("name");
    expect(tools[0]).toHaveProperty("description");
  });

  test("ar trebui să execute instrumentul și să returneze rezultat", async () => {
    const result = await server.callTool({
      name: "get_customer_info",
      arguments: { customer_id: "cust_123" },
    });
    expect(result).toBeDefined();
  });
});

FROM node:18-alpine

WORKDIR /app

COPY package*.json ./
RUN npm ci --only=production

COPY dist ./dist

EXPOSE 8000

CMD ["node", "dist/server.js"]

docker build -t my-mcp-server:1.0.0 .
docker push myregistry.azurecr.io/my-mcp-server:1.0.0

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"

# .env.production
OPENAI_API_KEY=sk-...
DATABASE_URL=postgresql://user:pass@host:5432/db
MCP_SERVER_PORT=8000
LOG_LEVEL=info
ENABLE_METRICS=true

async function processCustomerRefund(customerId: string, orderId: string, amount: number) {
  // Obține info client
  const customer = await getCustomerInfo(customerId);
  
  // Obține detalii comandă
  const order = await getOrderDetails(orderId);
  
  // Verifică dacă comanda aparține clientului
  if (order.customerId !== customerId) {
    throw new Error("Comanda nu aparține clientului");
  }
  
  // Procesează rambursarea
  const refund = await createRefund(orderId, amount);
  
  // Trimite notificare
  await sendNotification(customer.email, `Rambursare de $${amount} procesată`);
  
  return refund;
}

import NodeCache from "node-cache";

const cache = new NodeCache({ stdTTL: 600 }); // TTL 10 minute

async function getCustomerInfoWithCache(customerId: string) {
  const cacheKey = `customer_${customerId}`;
  
  // Caută mai întâi în cache
  const cached = cache.get(cacheKey);
  if (cached) {
    return cached;
  }
  
  // Ia din baza de date
  const customer = await getCustomerInfo(customerId);
  
  // Salvează în cache
  cache.set(cacheKey, customer);
  
  return customer;
}

import Bull from "bull";

const jobQueue = new Bull("mcp-jobs");

jobQueue.process(async (job) => {
  const { toolName, arguments: args } = job.data;
  
  // Execută instrumentul
  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: 200