Vytvorenie MCP servera, ktorý sa pripája k OpenAI: Kompletný sprievodca pre vývojárov

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

// Definujte nástroje
const tools = [
  {
    name: "get_customer_info",
    description: "Získajte informácie o zákazníkovi podľa ID",
    inputSchema: {
      type: "object",
      properties: {
        customer_id: {
          type: "string",
          description: "Jedinečný identifikátor zákazníka",
        },
      },
      required: ["customer_id"],
    },
  },
  // Pridajte ďalšie nástroje tu
];

// Spracovanie dopytu na zoznam nástrojov
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return { tools };
});

// Spracovanie dopytu na vykonanie nástroja
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  if (name === "get_customer_info") {
    // Implementujte logiku nástroja
    const customerId = args.customer_id;
    // Dotaz na databázu alebo API
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify({
            id: customerId,
            name: "John Doe",
            email: "john@example.com",
          }),
        },
      ],
    };
  }

  return {
    content: [{ type: "text", text: `Neznámy nástroj: ${name}` }],
    isError: true,
  };
});

// Spustenie servera
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")

# Definujte nástroje
TOOLS = [
    Tool(
        name="get_customer_info",
        description="Získajte informácie o zákazníkovi podľa 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")
        # Implementujte logiku nástroja
        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ámy nástroj: {name}")],
        isError=True
    )

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

import { Pool } from "pg"; // Príklad s 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 nebol nájdený",
        status: 404,
      };
    }

    return result.rows[0];
  } catch (error) {
    return {
      error: "Databázový dotaz zlyhal",
      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: "Volanie externého API zlyhalo",
      details: error.message,
    };
  }
}

function validateInput(args: any, schema: any): { valid: boolean; error?: string } {
  // Validácia povinných polí
  for (const required of schema.required || []) {
    if (!(required in args)) {
      return { valid: false, error: `Chýbajúci povinný parameter: ${required}` };
    }
  }

  // Validácia typov 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: `Parameter ${key} musí byť typu ${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() {
    // Pripojenie 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);

    // Získanie dostupných nástrojov
    const toolsResponse = await this.mcpClient.listTools();
    this.availableTools = toolsResponse.tools;
  }

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

    // Konverzia MCP nástrojov 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,
    });

    // Spracovanie volaní nástrojov v slučke
    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);

        // Vykonanie nástroja na MCP serveri
        const toolResult = await this.mcpClient.callTool({
          name: toolName,
          arguments: toolArgs,
        });

        // Pridanie výsledku nástroja do sprá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ískanie ďalšej odpovede z OpenAI
      response = await this.openaiClient.chat.completions.create({
        model: "gpt-4",
        messages,
        tools,
      });
    }

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

// Použitie
const bridge = new MCPOpenAIBridge();
await bridge.initialize();
const result = await bridge.executeWithOpenAI(
  "Aká je história objednávok zákazníka 12345?"
);
console.log(result);

import crypto from "crypto";

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

  constructor() {
    // Načítanie platných API kľúčov z prostredia alebo bezpečného úložiska
    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 minút
  max: 100, // maximálne 100 požiadaviek na IP za okno
  message: "Príliš veľa požiadaviek z tejto IP, skúste to neskôr.",
});

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

function sanitizeInput(input: string): string {
  // Odstráni potenciálne nebezpečné znaky
  return input
    .replace(/[<>]/g, "")
    .trim()
    .substring(0, 1000); // Limit dĺžky
}

function validateCustomerId(customerId: string): boolean {
  // Povolené len alfanumerické znaky a pomlčky
  return /^[a-zA-Z0-9-]+$/.test(customerId);
}

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

describe("Customer Tools", () => {
  test("vráti info o zákazníkovi pre platné ID", async () => {
    const result = await getCustomerInfo("cust_123");
    expect(result).toHaveProperty("id");
    expect(result).toHaveProperty("name");
    expect(result).toHaveProperty("email");
  });

  test("vráti chybu pre neplatné ID", async () => {
    const result = await getCustomerInfo("invalid");
    expect(result).toHaveProperty("error");
  });

  test("správne ošetrí chybu databázy", async () => {
    // Mock databázovej chyby
    const result = await getCustomerInfo("cust_error");
    expect(result).toHaveProperty("error");
    expect(result.status).toBe(500);
  });
});

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

  beforeAll(async () => {
    server = new Server({ name: "test-server", version: "1.0.0" });
    // Inicializácia servera
  });

  test("vráti všetky 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("vykoná nástroj a vráti výsledok", 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) {
  // Získanie info o zákazníkovi
  const customer = await getCustomerInfo(customerId);
  
  // Detail objednávky
  const order = await getOrderDetails(orderId);
  
  // Overenie, že objednávka patrí zákazníkovi
  if (order.customerId !== customerId) {
    throw new Error("Objednávka nepatrí zákazníkovi");
  }
  
  // Spracovanie refundácie
  const refund = await createRefund(orderId, amount);
  
  // Odoslanie notifikácie
  await sendNotification(customer.email, `Refundácia vo výške $${amount} bola spracovaná`);
  
  return refund;
}