TypeScript MCP-kiszolgáló létrehozása az Azure Container Apps használatával

Ez a cikk bemutatja, hogyan hozhat létre modellkörnyezeti protokoll (MCP) kiszolgálót Node.js és TypeScript használatával. A kiszolgáló kiszolgáló nélküli környezetben futtat eszközöket és szolgáltatásokat. Használja ezt a struktúrát kiindulási pontként egyéni MCP-kiszolgálók létrehozásához.

A kód megismerése

Ismerje meg a TypeScript távoli modellkörnyezeti protokoll (MCP) kiszolgálómintáját . Bemutatja, hogyan használható a Node.js és a TypeScript egy távoli MCP-kiszolgáló létrehozásához és az Azure Container Appsben való üzembe helyezéséhez.

A minta működésének megismeréséhez ugorjon a kódbemutató szakaszra .

Architekturális áttekintés

Az alábbi ábra a mintaalkalmazás egyszerű architektúráját mutatja be: Az ügynököt és MCP-ügyfelet üzemeltető Visual Studio Code-ból az MCP Serverre irányuló architektúrát bemutató ábra.

Az MCP-kiszolgáló tárolóalapú alkalmazásként fut az Azure Container Appsben (ACA). Egy Node.js/TypeScript háttérrendszer használatával biztosít eszközöket az MCP-ügyfélnek a Model Context Protocolon keresztül. Minden eszköz egy háttérbeli SQLite-adatbázissal működik.

Költség

A költségek alacsony szinten tartása érdekében ez a minta alapszintű vagy fogyasztási tarifacsomagokat használ a legtöbb erőforráshoz. Igény szerint állítsa be a szintet, és törölje az erőforrásokat, ha elkészült a díjak elkerülése érdekében.

Előfeltételek

  1. Visual Studio Code – Az MCP Server fejlesztését támogató legújabb verzió.
  2. GitHub Copilot Visual Studio Code-bővítmény
  3. GitHub Copilot Chat Visual Studio Code kiterjesztés
  4. Azure Developer CLI (azd)

A fejlesztői tároló tartalmazza a cikkhez szükséges összes függőséget. Futtathatja a GitHub Codespacesben (böngészőben) vagy helyileg a Visual Studio Code használatával.

A cikk követéséhez győződjön meg arról, hogy megfelel az alábbi előfeltételeknek:

Nyílt fejlesztési környezet

Az alábbi lépésekkel előre konfigurált fejlesztői környezetet állíthat be az összes szükséges függőséggel együtt.

A GitHub Codespaces egy, a GitHub által felügyelt fejlesztői tárolót futtat a Webes Visual Studio Code-tal felületként. A legegyszerűbb beállításhoz használja a GitHub Codespacest, mivel a cikkhez előre telepített szükséges eszközökkel és függőségekkel rendelkezik.

Fontos

Minden GitHub-fiók legfeljebb 60 órán át használhatja a Codespace-eket havonta két alapvető példánnyal. További információkért lásd: GitHub Codespaces havi tárterület- és alapóra-kontingense.

Az alábbi lépésekkel hozzon létre egy új GitHub-kódteret a mainAzure-Samples/mcp-container-ts GitHub-adattár ágán.

  1. Kattintson a jobb gombbal az alábbi gombra, és válassza a Hivatkozás megnyitása az új ablakban lehetőséget. Ez a művelet lehetővé teszi, hogy a fejlesztési környezet és a dokumentáció egymás mellett legyen megnyitva.

    Megnyitás a GitHub Codespaces-ben

  2. A Kódtér létrehozása lapon tekintse át, majd válassza az Új kódtér létrehozása lehetőséget.

  3. Várja meg, amíg a kódolási környezet elindul. Eltarthat néhány percig.

  4. Jelentkezzen be az Azure-ba az Azure Developer CLI-vel a képernyő alján található terminálon.

    azd auth login

  5. Másolja ki a kódot a terminálból, majd illessze be egy böngészőbe. Kövesse az utasításokat az Azure-fiókkal való hitelesítéshez.

A többi feladatot ebben a fejlesztési tárolóban hajtja végre.

Megjegyzés:

Az MCP-kiszolgáló helyi futtatása:

  1. Állítsa be a környezetet a mintaadattár Helyi környezet beállítás szakaszában leírtak szerint.
  2. Konfigurálja az MCP-kiszolgálót a helyi környezet használatára az MCP-kiszolgáló konfigurálása a Visual Studio Code-ban szakasz utasításait követve a mintaadattárban.
  3. A folytatáshoz ugorjon a TODO MCP-kiszolgálóeszközök használata ügynök módban szakaszra.

Üzembe helyezés és futtatás

A mintaadattár tartalmazza az MCP-kiszolgáló Azure-beli üzembe helyezéséhez szükséges összes kódot és konfigurációs fájlt. Az alábbi lépések végigvezetik az MCP szerver Azure alapú telepítési folyamatán.

Telepítés az Azure-ra

Fontos

Az ebben a szakaszban lévő Azure-erőforrások azonnal költségeket generálnak, akkor is, ha a parancsot a befejezés előtt leállítja.

  1. Futtassa a következő Azure Developer CLI-parancsot az Azure-erőforrások kiépítéséhez és a forráskód üzembe helyezéséhez:

    azd up

  2. Az alábbi táblázat segítségével válaszolhat a kérdésekre:

    Haladéktalan Válasz
    Környezet neve Legyen rövid és kisbetűs. Adja hozzá a nevét vagy aliasát. Például: my-mcp-server. Az erőforráscsoport nevének részeként használják.
    Előfizetés Válassza ki az előfizetést az erőforrások létrehozásához.
    Hely (üzemeltetéshez) Válasszon ki egy Önhöz közeli helyet a listából.
    Az Azure OpenAI-modell helye Válasszon ki egy Önhöz közeli helyet a listából. Ha ugyanaz a hely érhető el, mint az első hely, válassza ezt.

  3. Várja meg az alkalmazás üzembe helyezését. Az üzembe helyezés általában 5–10 percet vesz igénybe.

  4. Az üzembe helyezés befejezése után a kimenetben megadott URL-cím használatával érheti el az MCP-kiszolgálót. Az URL-cím így néz ki:

https://<env-name>.<container-id>.<region>.azurecontainerapps.io
  1. Másolja az URL-címet a vágólapra. A következő szakaszban szüksége lesz rá.

Az MCP-kiszolgáló konfigurálása a Visual Studio Code-ban

Konfigurálja az MCP-kiszolgálót a helyi VS Code-környezetben úgy, hogy hozzáadja az URL-címet a mcp.json.vscode mappában lévő fájlhoz.

  1. Nyissa meg a mcp.json fájlt a .vscode mappában.

  2. Keresse meg a mcp-server-sse-remote szakaszt a fájlban. Ennek így kell kinéznie:

        "mcp-server-sse-remote": {
    "type": "sse",
    "url": "https://<container-id>.<location>.azurecontainerapps.io/sse"
}

  3. Cserélje le a meglévő url értéket az előző lépésben másolt URL-címre.

  4. Mentse a mcp.json fájlt a .vscode mappába.

TODO MCP-kiszolgálóeszközök használata ügynök módban

Az MCP-kiszolgáló módosítása után használhatja az eszközöket, amelyet ügynök módban biztosít. Az MCP-eszközök használata ügynök módban:

  1. Nyissa meg a Csevegés nézetet (Ctrl+Alt+I), és válassza az Ügynök módot a legördülő listában.

  2. Kattintson az Eszközök gombra az elérhető eszközök listájának megtekintéséhez. Tetszés szerint jelölje ki vagy törölje a használni kívánt eszközök kijelölését. Az eszközök kereséséhez használja a keresőmezőt.

  3. A csevegés beviteli mezőjébe írja be a "Szerdán e-mailt kell küldenem a felettesemnek" üzenetet, és figyelje meg, hogy az eszközök szükség szerint automatikusan hogyan lesznek meghívva, ahogyan az alábbi képernyőképen látható:

    Képernyőkép az MCP-kiszolgáló eszközeinek meghívásával.

Megjegyzés:

Alapértelmezés szerint egy eszköz meghívásakor meg kell erősítenie a műveletet az eszköz futtatása előtt. Ellenkező esetben előfordulhat, hogy az eszközök helyileg futnak a számítógépen, és fájlokat vagy adatokat módosító műveleteket hajthatnak végre.

A Folytatás gomb legördülő menüjének használatával automatikusan megerősítheti az aktuális munkamenet, munkaterület vagy az összes jövőbeli hívás konkrét eszközét.

A mintakód felfedezése

Ez a szakasz áttekintést nyújt az MCP-kiszolgáló mintájában található kulcsfájlokról és kódstruktúráról. A kód több fő összetevőbe van rendezve:

  • index.ts: Az MCP-kiszolgáló fő belépési pontja, amely beállítja a Express.js HTTP-kiszolgálót és az útválasztást.
  • server.ts: Az Server-Sent események (SSE) kapcsolatait és az MCP protokollkezelést kezelő átviteli réteg.
  • tools.ts: Az MCP-kiszolgáló üzleti logikáját és segédprogramfüggvényét tartalmazza.
  • types.ts: Az MCP-kiszolgálón használt TypeScript-típusokat és interfészeket határozza meg.

index.ts – A kiszolgáló indítása és HTTP-kapcsolatok elfogadása

A index.ts fájl az MCP-kiszolgáló fő belépési pontja. Inicializálja a kiszolgálót, beállítja a Express.js HTTP-kiszolgálót, és meghatározza az útválasztást Server-Sent események (SSE) végpontjaihoz.

Az MCP-kiszolgálópéldány létrehozása

Az alábbi kódrészlet inicializálja az MCP-kiszolgálót az StreamableHTTPServer osztály használatával, amely egy burkoló az alapvető MCP-osztály Server körül. Ez az osztály kezeli az Server-Sent Események (SSE) átviteli rétegét, és kezeli az ügyfélkapcsolatokat.

const server = new StreamableHTTPServer(
  new Server(
    {
      name: 'todo-http-server',
      version: '1.0.0',
    },
    {
      capabilities: {
        tools: {},
      },
    }
  )
);

Fogalmak:

  • Összeállítási minta: SSEPServer az alacsony szintű Server osztály körbefuttatása
  • Képességek deklarálása: A kiszolgáló bejelenti, hogy támogatja az eszközöket (de nem erőforrásokat/kéréseket)
  • Elnevezési konvenció: A kiszolgáló neve az MCP-azonosítás részévé válik

Express-útvonalak beállítása

Az alábbi kódrészlet beállítja a Express.js kiszolgálót az SSE-kapcsolatok és az üzenetkezelés bejövő HTTP-kéréseinek kezelésére:

router.post('/messages', async (req: Request, res: Response) => {
  await server.handlePostRequest(req, res);
});

router.get('/sse', async (req: Request, res: Response) => {
  await server.handleGetRequest(req, res);
});

Fogalmak:

  • Két végpontos minta: GET SSE-kapcsolat létrehozásához, POST üzenetek küldéséhez
  • Delegálási minta: Az expressz útvonalak azonnal delegálnak SSEPServer

Folyamat életciklusának kezelése

A következő kódrészlet kezeli a kiszolgáló életciklusát, beleértve a kiszolgáló indítását és a leállási jeleken való kecses leállítását:

process.on('SIGINT', async () => {
  log.error('Shutting down server...');
  await server.close();
  process.exit(0);
});

Fogalmak:

  • Kecses leállítás: Megfelelő törlés a Ctrl+C billentyűkombináción
  • Aszinkron tisztítás: A kiszolgáló bezárása aszinkron módon történik
  • Erőforrás-kezelés: Fontos az SSE-kapcsolatokhoz

Átviteli réteg: server.ts

A server.ts fájl implementálja az MCP-kiszolgáló átviteli rétegét, különös tekintettel az Server-Sent események (SSE) kapcsolatainak kezelésére és az MCP protokollüzenetek útválasztására.

SSE-ügyfélkapcsolat beállítása és átvitel létrehozása

Az SSEPServer osztály az MCP-kiszolgálón Server-Sent események (SSE) kezelésére szolgáló fő átviteli réteg. Az SSEServerTransport osztályt használja az egyes ügyfélkapcsolatok kezelésére. Több átvitelt és azok életciklusát kezeli.

export class SSEPServer {
  server: Server;
  transport: SSEServerTransport | null = null;
  transports: Record<string, SSEServerTransport> = {};

  constructor(server: Server) {
    this.server = server;
    this.setupServerRequestHandlers();
  }
}

Fogalmak:

  • Állapotkezelés: Nyomon követi az aktuális és az összes szállítást
  • Munkamenet-leképezés: transports az objektum leképezi a munkamenet-azonosítókat az átviteli példányokra
  • Konstruktor-delegálás: Kéréskezelők azonnali beállítása

SSE-kapcsolat létesítése (handleGetRequest)

A handleGetRequest metódus feladata egy új SSE-kapcsolat létrehozása, amikor egy ügyfél GET kérést küld a /sse végponthoz.

async handleGetRequest(req: Request, res: Response) {
  log.info(`GET ${req.originalUrl} (${req.ip})`);
  try {
    log.info("Connecting transport to server...");
    this.transport = new SSEServerTransport("/messages", res);
    TransportsCache.set(this.transport.sessionId, this.transport);

    res.on("close", () => {
      if (this.transport) {
        TransportsCache.delete(this.transport.sessionId);
      }
    });

    await this.server.connect(this.transport);
    log.success("Transport connected. Handling request...");
  } catch (error) {
    // Error handling...
  }
}

Fogalmak:

  • Átvitel létrehozása: Új SSEServerTransport minden GET-kéréshez
  • Munkamenet-kezelés: Gyorsítótárban tárolt automatikus munkamenet-azonosító
  • Eseménykezelők: Törlés a kapcsolat bezárásakor
  • MCP-kapcsolat: server.connect() protokollkapcsolatot hoz létre
  • Aszinkron folyamat: A kapcsolat beállítása aszinkron hibahatárokkal

Üzenetfeldolgozás (handlePostRequest)

A handlePostRequest metódus feldolgozza a bejövő POST-kéréseket az ügyfél által küldött MCP-üzenetek kezelésére. A lekérdezési paraméterek munkamenet-azonosítóját használja a megfelelő átviteli példány megkereséséhez.

async handlePostRequest(req: Request, res: Response) {
  log.info(`POST ${req.originalUrl} (${req.ip}) - payload:`, req.body);

  const sessionId = req.query.sessionId as string;
  const transport = TransportsCache.get(sessionId);
  if (transport) {
    await transport.handlePostMessage(req, res, req.body);
  } else {
    log.error("Transport not initialized. Cannot handle POST request.");
    res.status(400).json(/* error response */);
  }
}

Fogalmak:

  • Munkamenet-keresés: A lekérdezési paraméter segítségével keresi meg az átvitelt.
  • Munkamenet-ellenőrzés: Először ellenőrzi az SSE-kapcsolatot.
  • Üzenetdelegálás: Az átvitel kezeli a tényleges üzenetfeldolgozást
  • Hibaválaszok: Megfelelő HTTP-hibakódok a hiányzó munkamenetekhez

MCP protokollkezelő beállítása (setupServerRequestHandlers)

A setupServerRequestHandlers metódus a következő kezelőket regisztrálja az MCP protokollkérelmekhez:

  • Ez egy kezelő az ListToolsRequestSchema számára, amely visszaadja az elérhető TODO-eszközök listáját.
  • Egy CallToolRequestSchema kezelő megkeresi és végrehajtja a kért eszközt a megadott argumentumokkal.

Ez a módszer Zod-sémákkal határozza meg a várt kérés- és válaszformátumokat.

private setupServerRequestHandlers() {
  this.server.setRequestHandler(ListToolsRequestSchema, async (_request) => {
    return {
      tools: TodoTools,
    };
  });
  
  this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
    const { name, arguments: args } = request.params;
    
    const tool = TodoTools.find((tool) => tool.name === name);
    if (!tool) {
      return this.createJSONErrorResponse(`Tool "${name}" not found.`);
    }
    
    const response = await tool.execute(args as any);
    return { content: [{ type: "text", text: response }] };
  });
}

Fogalmak:

  • Schema-Based Útválasztás: Zod-sémákat használ a típusbiztos kéréskezeléshez
  • Eszközfelderítés: ListToolsRequestSchema statikus TodoTools-tömböt ad vissza
  • Eszközvégrehajtás: CallToolRequestSchema eszközök keresése és végrehajtása
  • Hibakezelés: Ismeretlen eszközök kecses kezelése
  • Válaszformátum: MCP-kompatibilis válaszstruktúra
  • Típusbiztonság: A TypeScript-típusok biztosítják a helyes argumentumátadást

Üzleti logika: tools.ts

A tools.ts fájl az MCP-ügyfelek számára elérhető tényleges funkciókat határozza meg:

  • Eszköz metaadatai (név, leírás, sémák)
  • Bemeneti érvényesítési sémák
  • Eszközvégrehajtási logika
  • Integráció az adatbázisréteggel

Ez az MCP-kiszolgáló négy TODO felügyeleti eszközt határoz meg:

  • add_todo: Új TODO-elem létrehozása
  • complete_todo: TODO-elem megjelölése befejezettként
  • delete_todo: TODO-elem törlése
  • list_todos: Az összes TODO-elem listázása
  • update_todo_text: Meglévő TODO-elem szövegének frissítése

Eszközdefiníciós minta

Az eszközök objektumtömbként vannak definiálva, amelyek mindegyike egy adott TODO-műveletet jelöl. A addTodo eszköz a következő kódrészletben van definiálva.

{
  name: "addTodo",
  description: "Add a new TODO item to the list...",
  inputSchema: {
    type: "object",
    properties: {
      text: { type: "string" },
    },
    required: ["text"],
  },
  outputSchema: { type: "string" },
  async execute({ text }: { text: string }) {
    const info = await addTodo(text);
    return `Added TODO: ${text} (id: ${info.lastInsertRowid})`;
  },
}

Minden eszközdefiníció a következő:

  • name: Az eszköz egyedi azonosítója
  • description: Az eszköz céljának rövid leírása
  • inputSchema: A várt bemeneti formátumot meghatározó zod séma
  • outputSchema: A várt kimeneti formátumot meghatározó zod séma
  • execute: Az eszköz logikáját implementáló függvény

Ezeket az eszközdefiníciókat a server.ts-ban kerülnek importálásra, és a ListToolsRequestSchema kezelő által válnak elérhetővé.

Fogalmak:

  • Moduláris eszköztervezés: Minden eszköz egy önálló objektum
  • JSON-séma érvényesítése: inputSchema meghatározza a várt paramétereket
  • Típusbiztonság: A TypeScript-típusok megegyeznek a sémadefiníciókkal
  • Aszinkron végrehajtás: Minden eszközvégrehajtás aszinkron
  • Adatbázis-integráció: Meghívja az importált adatbázisfüggvényeket
  • Human-Readable Válaszok: Formázott sztringeket ad vissza, nem nyers adatokat

Eszköztömb exportálása

Az eszközök statikus tömbként vannak exportálva, így könnyen importálhatók és használhatók a kiszolgálón. Minden eszköz egy objektum, amelynek metaadatai és végrehajtási logikája van. Ez a struktúra lehetővé teszi, hogy az MCP-kiszolgáló dinamikusan felderítse és végrehajtsa az eszközöket az ügyfélkérések alapján.

export const TodoTools = [
  { /* addTodo */ },
  { /* listTodos */ },
  { /* completeTodo */ },
  { /* deleteTodo */ },
  { /* updateTodoText */ },
];

Fogalmak:

  • Statikus regisztráció: A modul betöltési idején definiált eszközök
  • Tömbstruktúra: Az egyszerű tömb megkönnyíti az eszközök iterálását
  • Importálás/exportálás: A kiszolgálólogikától való tiszta elkülönítés

Eszközvégrehajtási hibakezelés

Minden eszköz függvénye execute zökkenőmentesen kezeli a hibákat, és a kivételek helyett tiszta üzeneteket ad vissza. Ez a megközelítés biztosítja, hogy az MCP-kiszolgáló zökkenőmentes felhasználói élményt nyújtson.

Az eszközök különböző hibaforgatókönyveket kezelnek:

async execute({ id }: { id: number }) {
  const info = await completeTodo(id);
  if (info.changes === 0) {
    return `TODO with id ${id} not found.`;
  }
  return `Marked TODO ${id} as completed.`;
}

Fogalmak:

  • Adatbázis-válasz ellenőrzése: Hibák észlelésére használ info.changes
  • Kecses romlás: Leíró hibaüzeneteket ad vissza ellentétben a hiba kiváltásával
  • User-Friendly hibák: AI-értelmezésre alkalmas üzenetek

Adatréteg: db.ts

A db.ts fájl kezeli az SQLite adatbázis-kapcsolatot, és kezeli a TODO-alkalmazás CRUD-műveleteit. A tárat better-sqlite3 használja a szinkron adatbázis-hozzáféréshez.

Adatbázis inicializálása

Az adatbázis inicializálásához az SQLite-hez csatlakozik, és létrehoz táblákat, ha azok nem léteznek. Az alábbi kódrészlet az inicializálási folyamatot mutatja be:

const db = new Database(":memory:", {
  verbose: log.info,
});

try {
  db.pragma("journal_mode = WAL");
  db.prepare(
    `CREATE TABLE IF NOT EXISTS ${DB_NAME} (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     text TEXT NOT NULL,
     completed INTEGER NOT NULL DEFAULT 0
   )`
  ).run();
  log.success(`Database "${DB_NAME}" initialized.`);
} catch (error) {
  log.error(`Error initializing database "${DB_NAME}":`, { error });
}

Fogalmak:

  • In-Memory Adatbázis: :memory: az újraindításkor elveszett adatokat jelenti (csak bemutató/tesztelés)
  • WAL mód: Write-Ahead naplózás a teljesítmény javítása érdekében
  • Schema Definition: Egyszerű TODO-tábla autoinkrementáló azonosítóval
  • Hibakezelés: Az inicializálási hibák türelmes kezelése
  • Naplózási integráció: Az adatbázisműveleteket hibakeresés céljából naplózza a rendszer

CRUD műveleti minták

A db.ts fájl négy fő CRUD-műveletet biztosít a TODO-elemek kezeléséhez:

Létrehozási művelet:

export async function addTodo(text: string) {
  log.info(`Adding TODO: ${text}`);
  const stmt = db.prepare(`INSERT INTO todos (text, completed) VALUES (?, 0)`);
  return stmt.run(text);
}

Olvasási művelet:

export async function listTodos() {
  log.info("Listing all TODOs...");
  const todos = db.prepare(`SELECT id, text, completed FROM todos`).all() as Array<{
    id: number;
    text: string;
    completed: number;
  }>;
  return todos.map(todo => ({
    ...todo,
    completed: Boolean(todo.completed),
  }));
}

Frissítési művelet:

export async function completeTodo(id: number) {
  log.info(`Completing TODO with ID: ${id}`);
  const stmt = db.prepare(`UPDATE todos SET completed = 1 WHERE id = ?`);
  return stmt.run(id);
}

Törlési művelet:

export async function deleteTodo(id: number) {
  log.info(`Deleting TODO with ID: ${id}`);
  const row = db.prepare(`SELECT text FROM todos WHERE id = ?`).get(id) as
    | { text: string }
    | undefined;
  if (!row) {
    log.error(`TODO with ID ${id} not found`);
    return null;
  }
  db.prepare(`DELETE FROM todos WHERE id = ?`).run(id);
  log.success(`TODO with ID ${id} deleted`);
  return row;
}

Fogalmak:

  • Előkészített utasítások: Védelem az SQL-injektálás ellen
  • Típuskiosztás: Explicit TypeScript-típusok lekérdezési eredményekhez
  • Adatátalakítás: SQLite-egész számok átalakítása logikai értékekké
  • Atomi műveletek: Minden függvény egyetlen adatbázis-tranzakció
  • Visszaadott értékkonzisztencia: Függvények visszaadják a művelet metaadatait
  • Védekező programozás: Törlés előtti ellenőrzés minta

Sématervezés

Az adatbázisséma egy egyszerű SQL-utasítással van definiálva a db.ts fájlban. A todos tábla három mezőből áll:

CREATE TABLE todos (
  id INTEGER PRIMARY KEY AUTOINCREMENT,  -- Unique identifier
  text TEXT NOT NULL,                    -- TODO description  
  completed INTEGER NOT NULL DEFAULT 0   -- Boolean as integer
);

Segédeszközök: helpers/ könyvtár

A helpers/ könyvtár segédprogramfüggvényeket és osztályokat biztosít a kiszolgáló számára.

Strukturált naplózás hibakereséshez és monitorozáshoz: helpers/logs.ts

A helpers/logs.ts fájl egy strukturált naplózási segédprogramot biztosít az MCP-kiszolgálóhoz. A kódtárat a debug naplózáshoz és chalk a konzol színkódolt kimenetéhez használja.

export const logger = (namespace: string) => {
  const dbg = debug('mcp:' + namespace);
  const log = (colorize: ChalkInstance, ...args: any[]) => {
    const timestamp = new Date().toISOString();
    const formattedArgs = [timestamp, ...args].map((arg) => {
      if (typeof arg === 'object') {
        return JSON.stringify(arg, null, 2);
      }
      return arg;
    });
    dbg(colorize(formattedArgs.join(' ')));
  };

  return {
    info(...args: any[]) { log(chalk.cyan, ...args); },
    success(...args: any[]) { log(chalk.green, ...args); },
    warn(...args: any[]) { log(chalk.yellow, ...args); },
    error(...args: any[]) { log(chalk.red, ...args); },
  };
};

Munkamenetkezelés SSE-átvitelekhez: helpers/cache.ts

A helpers/cache.ts fájl az Map SSE-átvitelek munkamenet-azonosító szerinti tárolására szolgál. Ezzel a módszerrel a kiszolgáló gyorsan megtalálhatja és kezelheti az aktív kapcsolatokat.

import type { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse";

export const TransportsCache = new Map<string, SSEServerTransport>();

Megjegyzés:

Ez TransportsCache egy egyszerű memóriabeli gyorsítótár. Éles környezetben fontolja meg egy robusztusabb megoldás, például a Redis vagy egy adatbázis használatát a munkamenet-kezeléshez.

Végrehajtási folyamat összegzése

Az alábbi ábra az ügyféltől az MCP-kiszolgálóig és vissza irányuló kérések teljes menetét szemlélteti, beleértve az eszközvégrehajtást és az adatbázis-műveleteket:

Az ügyféltől az MCP-kiszolgálóig és vissza irányuló kérések teljes menetét bemutató ábra.

GitHub-kódterek tisztítása

Távolítsa el a GitHub Codespaces környezetet, hogy maximálisan kihasználhassa az ingyenes órákat magonként.

Fontos

A GitHub-fiók ingyenes tárhelyéről és alapóráiról további információt a GitHub Codespaces havonta tartalmazott tárhelye és alapórái című dokumentumban talál.

  1. Jelentkezzen be a GitHub Codespaces vezérlőpultjára.

  2. Keresse meg a Azure-Samples//mcp-container-ts GitHub-adattárból létrehozott aktív codespace-eket.

  3. Nyissa meg a kódtér helyi menüjét, és válassza a Törléslehetőséget.

Segítség kérése

Naplózza a problémát az adattár Issues részébe.

  • Last updated on