Files

T

wehub-resource-sync c275ba2868 chore: import upstream snapshot with attribution

2026-07-13 13:31:35 +08:00

18 KiB

Raw Permalink Blame History

MCP-server med stdio-transport

⚠️ Viktig oppdatering: Fra og med MCP-spesifikasjonen 2025-06-18 er den frittstående SSE (Server-Sent Events)-transporten utfaset og erstattet av "Strømmbar HTTP" transport. Den nåværende MCP-spesifikasjonen definerer to primære transportmekanismer:

stdio - Standard input/output (anbefalt for lokale servere)

Strømmbar HTTP - For fjernservere som kan bruke SSE internt

Denne leksjonen er oppdatert for å fokusere på stdio-transporten, som er den anbefalte tilnærmingen for de fleste MCP-serverimplementeringer.

Stdio-transporten tillater MCP-servere å kommunisere med klienter via standard input- og output-strømmer. Dette er den mest brukte og anbefalte transportmekanismen i den nåværende MCP-spesifikasjonen, og gir en enkel og effektiv måte å bygge MCP-servere som enkelt kan integreres med ulike klientapplikasjoner.

Oversikt

Denne leksjonen dekker hvordan du bygger og bruker MCP-servere ved hjelp av stdio-transporten.

Læringsmål

Ved slutten av denne leksjonen vil du kunne:

Bygge en MCP-server med stdio-transport.
Feilsøke en MCP-server med Inspector.
Bruke en MCP-server i Visual Studio Code.
Forstå dagens MCP-transportmekanismer og hvorfor stdio anbefales.

stdio-transport – Hvordan det fungerer

Stdio-transporten er en av to støttede transporttyper i den nåværende MCP-spesifikasjonen (2025-11-25). Slik fungerer den:

Enkel kommunikasjon: Serveren leser JSON-RPC-meldinger fra standard input (stdin) og sender meldinger til standard output (stdout).
Prosessbasert: Klienten starter MCP-serveren som en underprosess.
Meldingsformat: Meldinger er individuelle JSON-RPC-forespørsler, varsler eller svar, avgrenset av linjeskift.
Logging: Serveren KAN skrive UTF-8-strenger til standard feil (stderr) for loggformål.

Viktige krav:

Meldinger MÅ avgrenses av linjeskift og MÅ IKKE inneholde innebygde linjeskift
Serveren MÅ IKKE skrive noe til stdout som ikke er en gyldig MCP-melding
Klienten MÅ IKKE skrive noe til serverens stdin som ikke er en gyldig MCP-melding

TypeScript

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server(
  {
    name: "example-server",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

async function runServer() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
}

runServer().catch(console.error);

I koden over:

Importerer vi Server-klassen og StdioServerTransport fra MCP SDK
Oppretter en serverinstans med grunnleggende konfigurasjon og kapasiteter
Lager en StdioServerTransport-instans og kobler serveren til den, noe som gjør det mulig å kommunisere over stdin/stdout

Python

import asyncio
import logging
from mcp.server import Server
from mcp.server.stdio import stdio_server

# Opprett serverinstans
server = Server("example-server")

@server.tool()
def add(a: int, b: int) -> int:
    """Add two numbers"""
    return a + b

async def main():
    async with stdio_server(server) as (read_stream, write_stream):
        await server.run(
            read_stream,
            write_stream,
            server.create_initialization_options()
        )

if __name__ == "__main__":
    asyncio.run(main())

I koden over:

Oppretter vi en serverinstans med MCP SDK
Definerer verktøy med dekoratører
Bruker stdio_server-kontekstbehandleren for å håndtere transporten

.NET

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using ModelContextProtocol.Server;

var builder = Host.CreateApplicationBuilder(args);

builder.Services
    .AddMcpServer()
    .WithStdioServerTransport()
    .WithTools<Tools>();

builder.Services.AddLogging(logging => logging.AddConsole());

var app = builder.Build();
await app.RunAsync();

Den viktigste forskjellen fra SSE er at stdio-servere:

Krever ikke oppsett av webserver eller HTTP-endepunkter
Startes som underprosesser av klienten
Kommuniserer via stdin/stdout-strømmer
Er enklere å implementere og feilsøke

Øvelse: Lage en stdio-server

For å lage vår server må vi huske på to ting:

Vi trenger å bruke en webserver for å eksponere endepunkter for tilkobling og meldinger.

Lab: Lage en enkel MCP stdio-server

I denne labben skal vi lage en enkel MCP-server med den anbefalte stdio-transporten. Denne serveren vil eksponere verktøy klienter kan kalle ved hjelp av standard Model Context Protocol.

Forutsetninger

Python 3.8 eller nyere
MCP Python SDK: pip install mcp
Grunnleggende forståelse av asynkron programmering

La oss begynne med å lage vår første MCP stdio-server:

import asyncio
import logging
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp import types

# Konfigurer logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Opprett serveren
server = Server("example-stdio-server")

@server.tool()
def calculate_sum(a: int, b: int) -> int:
    """Calculate the sum of two numbers"""
    return a + b

@server.tool() 
def get_greeting(name: str) -> str:
    """Generate a personalized greeting"""
    return f"Hello, {name}! Welcome to MCP stdio server."

async def main():
    # Bruk stdio transport
    async with stdio_server(server) as (read_stream, write_stream):
        await server.run(
            read_stream,
            write_stream,
            server.create_initialization_options()
        )

if __name__ == "__main__":
    asyncio.run(main())

Viktige forskjeller fra den utgåtte SSE-tilnærmingen

Stdio Transport (Nåværende standard):

Enkel underprosessmodell – klient starter server som barneprosess
Kommunikasjon via stdin/stdout med JSON-RPC-meldinger
Krever ikke HTTP-serveroppsett
Bedre ytelse og sikkerhet
Enklere feilsøking og utvikling

SSE-transport (Utgått fra MCP 2025-06-18):

Krevde HTTP-server med SSE-endepunkter
Mer komplisert oppsett med webserver-infrastruktur
Ytterligere sikkerhetshensyn for HTTP-endepunkter
Erstattet av Strømmbar HTTP for nettbaserte scenarioer

Lage en server med stdio-transport

For å lage vår stdio-server må vi:

Importere nødvendige biblioteker – Vi trenger MCP-serverkomponentene og stdio-transporten
Opprette en serverinstans – Definere serveren med dens kapasiteter
Definere verktøy – Legge til funksjonalitet vi ønsker å eksponere
Sette opp transporten – Konfigurere stdio-kommunikasjon
Kjøre serveren – Starte serveren og håndtere meldinger

La oss bygge dette steg for steg:

Steg 1: Lag en enkel stdio-server

import asyncio
import logging
from mcp.server import Server
from mcp.server.stdio import stdio_server

# Konfigurer logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Opprett serveren
server = Server("example-stdio-server")

@server.tool()
def get_greeting(name: str) -> str:
    """Generate a personalized greeting"""
    return f"Hello, {name}! Welcome to MCP stdio server."

async def main():
    async with stdio_server(server) as (read_stream, write_stream):
        await server.run(
            read_stream,
            write_stream,
            server.create_initialization_options()
        )

if __name__ == "__main__":
    asyncio.run(main())

Steg 2: Legg til flere verktøy

@server.tool()
def calculate_sum(a: int, b: int) -> int:
    """Calculate the sum of two numbers"""
    return a + b

@server.tool()
def calculate_product(a: int, b: int) -> int:
    """Calculate the product of two numbers"""
    return a * b

@server.tool()
def get_server_info() -> dict:
    """Get information about this MCP server"""
    return {
        "server_name": "example-stdio-server",
        "version": "1.0.0",
        "transport": "stdio",
        "capabilities": ["tools"]
    }

Steg 3: Kjøre serveren

Lagre koden som server.py og kjør den fra kommandolinjen:

python server.py

Serveren vil starte og vente på input fra stdin. Den kommuniserer ved hjelp av JSON-RPC-meldinger over stdio-transporten.

Steg 4: Teste med Inspector

Du kan teste serveren din med MCP Inspector:

Installer Inspector: npx @modelcontextprotocol/inspector
Kjør Inspector og pek den til serveren din
Test verktøyene du har laget

.NET

var builder = WebApplication.CreateBuilder(args);
builder.Services
    .AddMcpServer();

Feilsøking av din stdio-server

Bruke MCP Inspector

MCP Inspector er et verdifullt verktøy for feilsøking og testing av MCP-servere. Slik bruker du det med din stdio-server:

Installer Inspector:
```
npx @modelcontextprotocol/inspector
```

Kjør Inspector:

npx @modelcontextprotocol/inspector python server.py

Test serveren din: Inspector gir et webgrensesnitt hvor du kan:
- Se serverens kapasiteter
- Teste verktøy med ulike parametere
- Overvåke JSON-RPC-meldinger
- Feilsøke tilkoblingsproblemer

Bruke VS Code

Du kan også feilsøke MCP-serveren din direkte i VS Code:

Lag en launch-konfigurasjon i .vscode/launch.json:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Debug MCP Server",
      "type": "python",
      "request": "launch",
      "program": "server.py",
      "console": "integratedTerminal"
    }
  ]
}

Sett breakpoints i serverkoden din
Kjør debuggeren og test med Inspector

Vanlige feilsøkingstips

Bruk stderr til logging – skriv aldri til stdout da det er reservert for MCP-meldinger
Sørg for at alle JSON-RPC-meldinger er linjeavgrenset
Test med enkle verktøy først før du legger til kompleks funksjonalitet
Bruk Inspector for å verifisere meldingsformater

Bruke stdio-serveren din i VS Code

Når du har laget MCP stdio-serveren din, kan du integrere den med VS Code for å bruke den med Claude eller andre MCP-kompatible klienter.

Konfigurasjon

Lag en MCP-konfigurasjonsfil på %APPDATA%\Claude\claude_desktop_config.json (Windows) eller ~/Library/Application Support/Claude/claude_desktop_config.json (Mac):

{
  "mcpServers": {
    "example-stdio-server": {
      "command": "python",
      "args": ["path/to/your/server.py"]
    }
  }
}

Restart Claude: Lukk og åpne Claude på nytt for å laste den nye serverkonfigurasjonen.
Test tilkoblingen: Start en samtale med Claude og prøv å bruke serverens verktøy:
- "Kan du hilse på meg med hilseverktøyet?"
- "Kalkuler summen av 15 og 27"
- "Hva er serverinformasjonen?"

TypeScript stdio-server eksempel

Her er et komplett TypeScript-eksempel for referanse:

#!/usr/bin/env node
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: "example-stdio-server",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

// Legg til verktøy
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "get_greeting",
        description: "Get a personalized greeting",
        inputSchema: {
          type: "object",
          properties: {
            name: {
              type: "string",
              description: "Name of the person to greet",
            },
          },
          required: ["name"],
        },
      },
    ],
  };
});

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === "get_greeting") {
    return {
      content: [
        {
          type: "text",
          text: `Hello, ${request.params.arguments?.name}! Welcome to MCP stdio server.`,
        },
      ],
    };
  } else {
    throw new Error(`Unknown tool: ${request.params.name}`);
  }
});

async function runServer() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
}

runServer().catch(console.error);

.NET stdio-server eksempel

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using ModelContextProtocol.Server;
using System.ComponentModel;

var builder = Host.CreateApplicationBuilder(args);

builder.Services
    .AddMcpServer()
    .WithStdioServerTransport()
    .WithTools<Tools>();

var app = builder.Build();
await app.RunAsync();

[McpServerToolType]
public class Tools
{
    [McpServerTool, Description("Get a personalized greeting")]
    public string GetGreeting(string name)
    {
        return $"Hello, {name}! Welcome to MCP stdio server.";
    }

    [McpServerTool, Description("Calculate the sum of two numbers")]
    public int CalculateSum(int a, int b)
    {
        return a + b;
    }
}

Oppsummering

I denne oppdaterte leksjonen lærte du hvordan du:

Bygger MCP-servere ved bruk av nåværende stdio-transport (anbefalt tilnærming)
Forstår hvorfor SSE-transporten ble utfaset til fordel for stdio og Strømmbar HTTP
Lager verktøy som kan kalles av MCP-klienter
Feilsøker serveren din med MCP Inspector
Integrerer stdio-serveren med VS Code og Claude

Stdio-transporten tilbyr en enklere, sikrere og mer ytelseseffektiv måte å bygge MCP-servere på sammenlignet med den utgåtte SSE-tilnærmingen. Den er den anbefalte transporten for de fleste MCP-serverimplementeringer per spesifikasjonen fra 2025-06-18.

.NET

La oss lage noen verktøy først, til dette skal vi lage en fil Tools.cs med følgende innhold:

using System.ComponentModel;
using System.Text.Json;
using ModelContextProtocol.Server;

Øvelse: Teste din stdio-server

Nå som du har bygget din stdio-server, la oss teste den for å sikre at den fungerer korrekt.

Forutsetninger

Sørg for at du har installert MCP Inspector:

npm install -g @modelcontextprotocol/inspector

Serverkoden din skal være lagret (f.eks. som server.py)

Testing med Inspector

Start Inspector med serveren din:

npx @modelcontextprotocol/inspector python server.py

Åpne webgrensesnittet: Inspector åpner et nettleservindu som viser serverens kapasiteter.
Test verktøyene:
- Prøv get_greeting-verktøyet med ulike navn
- Test calculate_sum-verktøyet med forskjellige tall
- Kall get_server_info-verktøyet for å se servermetadata
Overvåk kommunikasjonen: Inspector viser JSON-RPC-meldinger som utveksles mellom klient og server.

Hva du bør se

Når serveren starter riktig, bør du se:

Serverkapasiteter listet i Inspector
Verktøy tilgjengelige for testing
Vellykkede JSON-RPC-meldingsutvekslinger
Verktøyrespons vist i grensesnittet

Vanlige problemer og løsninger

Serveren starter ikke:

Sjekk at alle avhengigheter er installert: pip install mcp
Verifiser Python-syntaks og innrykk
Se etter feilmeldinger i konsollen

Verktøy vises ikke:

Forsikre deg om at @server.tool()-dekoratører er tilstede
Sjekk at verktøyfunksjoner er definert før main()
Sørg for at serveren er korrekt konfigurert

Tilkoblingsproblemer:

Kontroller at serveren bruker stdio-transporten riktig
Sjekk at ingen andre prosesser forstyrrer
Verifiser Inspector-kommandoens syntaks

Oppgave

Prøv å bygge ut serveren med flere kapasiteter. Se denne siden for eksempel, for å legge til et verktøy som kaller en API. Du bestemmer hvordan serveren skal se ut. Lykke til :)

Løsning

Løsning Her er en mulig løsning med fungerende kode.

Viktige punkter

De viktigste punktene fra dette kapitlet er:

Stdio-transport er den anbefalte mekanismen for lokale MCP-servere.
Stdio-transport tillater sømløs kommunikasjon mellom MCP-servere og klienter via standard input- og output-strømmer.
Du kan bruke både Inspector og Visual Studio Code for å konsumere stdio-servere direkte, noe som gjør feilsøking og integrasjon enkelt.

Eksempler

Ekstra ressurser

Hva nå?

Neste steg

Nå som du har lært hvordan du bygger MCP-servere med stdio-transporten, kan du utforske mer avanserte temaer:

Neste: HTTP-strømming med MCP (Strømmbar HTTP) – Lær om den andre støttede transportmekanismen for fjernservere
Avansert: MCP sikkerhetspraksis – Implementer sikkerhet i dine MCP-servere
Produksjon: Distribusjonsstrategier – Distribuer serverne dine for produksjonsbruk

Ekstra ressurser

MCP-spesifikasjon 2025-11-25 – Offisiell spesifikasjon
MCP SDK-dokumentasjon – SDK-referanser for alle språk
Community-eksempler – Flere servereksempler fra communityet

Ansvarsfraskrivelse: Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten Co-op Translator. Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det opprinnelige dokumentet på originalspråket skal betraktes som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.

18 KiB Raw Permalink Blame History Unescape Escape

MCP-server med stdio-transport

Oversikt

Læringsmål

stdio-transport – Hvordan det fungerer

Viktige krav:

TypeScript

Python

.NET

Øvelse: Lage en stdio-server

Lab: Lage en enkel MCP stdio-server

Forutsetninger

Viktige forskjeller fra den utgåtte SSE-tilnærmingen

Lage en server med stdio-transport

Steg 1: Lag en enkel stdio-server

Steg 2: Legg til flere verktøy

Steg 3: Kjøre serveren

Steg 4: Teste med Inspector

.NET

Feilsøking av din stdio-server

Bruke MCP Inspector

Bruke VS Code

Vanlige feilsøkingstips

Bruke stdio-serveren din i VS Code

Konfigurasjon

TypeScript stdio-server eksempel

.NET stdio-server eksempel

Oppsummering

.NET

Øvelse: Teste din stdio-server

Forutsetninger

Testing med Inspector

Hva du bør se

Vanlige problemer og løsninger

Oppgave

Løsning

Viktige punkter

Eksempler

Ekstra ressurser

Hva nå?

Neste steg

Ekstra ressurser

18 KiB

Raw Permalink Blame History