Model Context Protocol (MCP) er en kraftfull, standardisert ramme som optimaliserer kommunikasjonen mellom store språkmodeller (LLMs) og eksterne verktøy, applikasjoner og datakilder. Denne SEO-optimaliserte guiden tar deg gjennom kjernebegrepene i MCP, slik at du forstår klient-server-arkitekturen, viktige komponenter, kommunikasjonsmekanismer og beste praksis for implementering.
Denne leksjonen utforsker den grunnleggende arkitekturen og komponentene som utgjør Model Context Protocol (MCP)-økosystemet. Du vil lære om klient-server-arkitektur, nøkkelkomponenter og kommunikasjonsmekanismer som driver MCP-interaksjoner.
Ved slutten av denne leksjonen vil du:
- Forstå MCPs klient-server-arkitektur.
- Identifisere roller og ansvar for Hosts, Clients og Servers.
- Analysere kjernefunksjonene som gjør MCP til et fleksibelt integrasjonslag.
- Lære hvordan informasjon flyter innen MCP-økosystemet.
- Få praktisk innsikt gjennom kodeeksempler i .NET, Java, Python og JavaScript.
MCP-økosystemet er bygget på en klient-server-modell. Denne modulære strukturen gjør det mulig for AI-applikasjoner å effektivt samhandle med verktøy, databaser, API-er og kontekstuelle ressurser. La oss bryte ned denne arkitekturen i dens kjernekomponenter.
I Model Context Protocol (MCP) spiller Hosts en avgjørende rolle som hovedgrensesnittet brukere benytter for å samhandle med protokollen. Hosts er applikasjoner eller miljøer som initierer tilkoblinger med MCP-servere for å få tilgang til data, verktøy og prompts. Eksempler på Hosts inkluderer integrerte utviklingsmiljøer (IDEer) som Visual Studio Code, AI-verktøy som Claude Desktop, eller egendefinerte agenter designet for spesifikke oppgaver.
Hosts er LLM-applikasjoner som initierer tilkoblinger. De:
- Kjører eller samhandler med AI-modeller for å generere svar.
- Starter tilkoblinger med MCP-servere.
- Styrer samtaleflyten og brukergrensesnittet.
- Kontrollerer tillatelser og sikkerhetsbegrensninger.
- Håndterer brukerens samtykke for datadeling og verktøyutførelse.
Clients er essensielle komponenter som legger til rette for interaksjonen mellom Hosts og MCP-servere. Clients fungerer som mellomledd og gjør det mulig for Hosts å få tilgang til og bruke funksjonaliteten som MCP-servere tilbyr. De spiller en viktig rolle i å sikre smidig kommunikasjon og effektiv datautveksling innen MCP-arkitekturen.
Clients er koblinger inne i host-applikasjonen. De:
- Sender forespørsler til servere med prompts/instruksjoner.
- Forhandler om funksjonaliteter med servere.
- Håndterer forespørsler om verktøyutførelse fra modeller.
- Behandler og viser svar til brukerne.
Servers har ansvar for å håndtere forespørsler fra MCP-klienter og gi passende svar. De styrer ulike operasjoner som datainnhenting, verktøyutførelse og promptgenerering. Servers sikrer at kommunikasjonen mellom klienter og Hosts er effektiv og pålitelig, og opprettholder integriteten i interaksjonsprosessen.
Servers er tjenester som tilbyr kontekst og funksjonalitet. De:
- Registrerer tilgjengelige funksjoner (ressurser, prompts, verktøy).
- Mottar og utfører verktøy-kall fra klienten.
- Gir kontekstuell informasjon for å forbedre modellens svar.
- Returnerer resultater tilbake til klienten.
- Opprettholder tilstand over flere interaksjoner ved behov.
Servers kan utvikles av hvem som helst for å utvide modellens kapabiliteter med spesialisert funksjonalitet.
Servers i Model Context Protocol (MCP) tilbyr grunnleggende byggesteiner som muliggjør rike interaksjoner mellom klienter, hosts og språkmodeller. Disse funksjonene er designet for å forbedre MCPs kapabiliteter ved å tilby strukturert kontekst, verktøy og prompts.
MCP-servere kan tilby noen av følgende funksjoner:
Ressurser i Model Context Protocol (MCP) omfatter ulike typer kontekst og data som kan brukes av brukere eller AI-modeller. Disse inkluderer:
- Kontekstuell data: Informasjon og kontekst som brukere eller AI-modeller kan benytte til beslutningstaking og oppgaveutførelse.
- Kunnskapsbaser og dokumentarkiver: Samlinger av strukturert og ustrukturert data, som artikler, manualer og forskningsartikler, som gir verdifulle innsikter og informasjon.
- Lokale filer og databaser: Data lagret lokalt på enheter eller i databaser, tilgjengelig for behandling og analyse.
- API-er og webtjenester: Eksterne grensesnitt og tjenester som tilbyr ekstra data og funksjonalitet, og muliggjør integrasjon med ulike nettressurser og verktøy.
Et eksempel på en ressurs kan være et databaseskjema eller en fil som kan aksesseres slik:
file://log.txt
database://schema
Prompts i Model Context Protocol (MCP) inkluderer ulike forhåndsdefinerte maler og interaksjonsmønstre som er designet for å effektivisere brukerflyt og forbedre kommunikasjon. Disse inkluderer:
- Malbaserte meldinger og arbeidsflyter: Forhåndsstrukturerte meldinger og prosesser som veileder brukere gjennom spesifikke oppgaver og interaksjoner.
- Forhåndsdefinerte interaksjonsmønstre: Standardiserte sekvenser av handlinger og svar som legger til rette for konsistent og effektiv kommunikasjon.
- Spesialiserte samtalemaler: Tilpassbare maler skreddersydd for spesifikke typer samtaler, som sikrer relevante og kontekstuelt passende interaksjoner.
En prompt-mal kan se slik ut:
Generate a product slogan based on the following {{product}} with the following {{keywords}}Verktøy i Model Context Protocol (MCP) er funksjoner som AI-modellen kan utføre for å løse spesifikke oppgaver. Disse verktøyene er designet for å forbedre AI-modellens kapabiliteter ved å tilby strukturerte og pålitelige operasjoner. Viktige aspekter inkluderer:
- Funksjoner som AI-modellen kan kjøre: Verktøy er kjørbare funksjoner som AI-modellen kan påkalle for å utføre ulike oppgaver.
- Unikt navn og beskrivelse: Hvert verktøy har et distinkt navn og en detaljert beskrivelse som forklarer formålet og funksjonaliteten.
- Parametere og output: Verktøy tar imot spesifikke parametere og returnerer strukturerte resultater, noe som sikrer konsistente og forutsigbare utfall.
- Diskrete funksjoner: Verktøy utfører avgrensede funksjoner som nettsøk, beregninger og databaseforespørsler.
Et eksempel på et verktøy kan se slik ut:
server.tool(
"GetProducts",
{
pageSize: z.string().optional(),
pageCount: z.string().optional()
}, () => {
// return results from API
}
)I Model Context Protocol (MCP) tilbyr klienter flere viktige funksjoner til servere, som forbedrer protokollens samlede funksjonalitet og interaksjon. En av de mest bemerkelsesverdige funksjonene er Sampling.
- Server-initierte agentiske handlinger: Klienter gjør det mulig for servere å initiere spesifikke handlinger eller atferd autonomt, noe som øker systemets dynamiske kapabiliteter.
- Rekursive LLM-interaksjoner: Denne funksjonen tillater rekursive interaksjoner med store språkmodeller (LLMs), noe som muliggjør mer komplekse og iterative oppgaveprosesser.
- Forespørsel om flere modellkompletteringer: Servere kan be om flere fullføringer fra modellen for å sikre grundige og kontekstuelt relevante svar.
Model Context Protocol (MCP) definerer en strukturert flyt av informasjon mellom hosts, clients, servers og modeller. Å forstå denne flyten bidrar til å klargjøre hvordan brukerforespørsler behandles og hvordan eksterne verktøy og data integreres i modellens svar.
-
Host initierer tilkobling
Host-applikasjonen (som et IDE eller chat-grensesnitt) etablerer en tilkobling til en MCP-server, vanligvis via STDIO, WebSocket eller en annen støttet transport. -
Funksjonsforhandling
Klienten (innebygd i hosten) og serveren utveksler informasjon om hvilke funksjoner, verktøy, ressurser og protokollversjoner de støtter. Dette sikrer at begge parter forstår hvilke kapabiliteter som er tilgjengelige i økten. -
Brukerforespørsel
Brukeren samhandler med hosten (f.eks. skriver inn en prompt eller kommando). Hosten samler inn denne inputen og sender den til klienten for behandling. -
Bruk av ressurs eller verktøy
- Klienten kan be om ekstra kontekst eller ressurser fra serveren (som filer, databaseoppføringer eller kunnskapsbaseartikler) for å berike modellens forståelse.
- Hvis modellen avgjør at et verktøy er nødvendig (f.eks. for å hente data, utføre en beregning eller kalle et API), sender klienten en verktøysinvokasjonsforespørsel til serveren, med navn på verktøyet og parametere.
-
Serverutførelse
Serveren mottar forespørselen om ressurs eller verktøy, utfører nødvendige operasjoner (som å kjøre en funksjon, spørre en database eller hente en fil) og returnerer resultatene til klienten i et strukturert format. -
Svargenerering
Klienten integrerer serverens svar (ressursdata, verktøyutdata osv.) i den pågående modellinteraksjonen. Modellen bruker denne informasjonen til å generere et helhetlig og kontekstuelt relevant svar. -
Resultatpresentasjon
Hosten mottar det endelige resultatet fra klienten og viser det til brukeren, ofte med både modellens genererte tekst og eventuelle resultater fra verktøyutførelser eller ressursoppslag.
Denne flyten gjør det mulig for MCP å støtte avanserte, interaktive og kontekstbevisste AI-applikasjoner ved sømløst å koble modeller med eksterne verktøy og datakilder.
MCP (Model Context Protocol) er bygget på toppen av JSON-RPC 2.0, og tilbyr et standardisert, språkagnostisk meldingsformat for kommunikasjon mellom hosts, clients og servers. Dette grunnlaget muliggjør pålitelig, strukturert og utvidbar kommunikasjon på tvers av ulike plattformer og programmeringsspråk.
MCP utvider JSON-RPC 2.0 med tilleggskonvensjoner for verktøysinvokasjon, ressursaksess og prompthåndtering. Den støtter flere transportlag (STDIO, WebSocket, SSE) og muliggjør sikker, utvidbar og språkagnostisk kommunikasjon mellom komponenter.
- JSON-RPC meldingsformat: Alle forespørsler og svar bruker JSON-RPC 2.0-spesifikasjonen, som sikrer konsistent struktur for metodekall, parametere, resultater og feilhåndtering.
- Stateful tilkoblinger: MCP-økter opprettholder tilstand over flere forespørsler, og støtter pågående samtaler, akkumulering av kontekst og ressursstyring.
- Funksjonsforhandling: Under tilkoblingsoppsett utveksler klienter og servere informasjon om støttede funksjoner, protokollversjoner, tilgjengelige verktøy og ressurser. Dette sikrer at begge parter forstår hverandres kapabiliteter og kan tilpasse seg.
Nedenfor er noen ekstra verktøy og protokollutvidelser som MCP tilbyr for å forbedre utvikleropplevelsen og muliggjøre avanserte scenarier:
- Konfigurasjonsvalg: MCP tillater dynamisk konfigurering av øktparametere, som verktøystillatelser, ressursaksess og modellinnstillinger, tilpasset hver interaksjon.
- Fremdriftssporing: Langvarige operasjoner kan rapportere fremdriftsoppdateringer, noe som muliggjør responsive brukergrensesnitt og bedre brukeropplevelse under komplekse oppgaver.
- Avbrytelse av forespørsler: Klienter kan avbryte pågående forespørsler, slik at brukere kan stoppe operasjoner som ikke lenger er nødvendige eller tar for lang tid.
- Feilmelding: Standardiserte feilmeldinger og koder hjelper til med feilsøking, håndtering av feil på en ryddig måte og gir handlingsrettet tilbakemelding til brukere og utviklere.
- Logging: Både klienter og servere kan sende strukturerte logger for revisjon, feilsøking og overvåking av protokollinteraksjoner.
Ved å utnytte disse protokollfunksjonene sikrer MCP robust, sikker og fleksibel kommunikasjon mellom språkmodeller og eksterne verktøy eller datakilder.
MCP-implementasjoner bør følge flere viktige sikkerhetsprinsipper for å sikre trygge og pålitelige interaksjoner:
-
Brukersamtykke og kontroll: Brukere må gi eksplisitt samtykke før noen data blir aksessert eller operasjoner utført. De bør ha klar kontroll over hvilke data som deles og hvilke handlinger som godkjennes, støttet av intuitive brukergrensesnitt for å gjennomgå og godkjenne aktiviteter.
-
Dataprivacy: Brukerdata skal kun eksponeres med eksplisitt samtykke og må beskyttes med passende tilgangskontroller. MCP-implementasjoner må forhindre uautorisert datatransmisjon og sikre at personvern opprettholdes gjennom alle interaksjoner.
-
Verktøysikkerhet: Før noen verktøy påkalles, kreves eksplisitt brukersamtykke. Brukere bør ha god forståelse av hvert verktøys funksjonalitet, og robuste sikkerhetsgrenser må håndheves for å forhindre utilsiktet eller usikker verktøyutførelse.
Ved å følge disse prinsippene sikrer MCP at brukerens tillit, personvern og sikkerhet opprettholdes i alle protokollinteraksjoner.
Nedenfor finner du kodeeksempler i flere populære programmeringsspråk som illustrerer hvordan man kan implementere sentrale MCP-serverkomponenter og verktøy.
Her er et praktisk .NET-kodeeksempel som viser hvordan man implementerer en enkel MCP-server med egendefinerte verktøy. Eksemplet demonstrerer hvordan man definerer og registrerer verktøy, håndterer forespørsler og kobler serveren med Model Context Protocol.
using System;
using System.Threading.Tasks;
using ModelContextProtocol.Server;
using ModelContextProtocol.Server.Transport;
using ModelContextProtocol.Server.Tools;
public class WeatherServer
{
public static async Task Main(string[] args)
{
// Create an MCP server
var server = new McpServer(
name: "Weather MCP Server",
version: "1.0.0"
);
// Register our custom weather tool
server.AddTool<string, WeatherData>("weatherTool",
description: "Gets current weather for a location",
execute: async (location) => {
// Call weather API (simplified)
var weatherData = await GetWeatherDataAsync(location);
return weatherData;
});
// Connect the server using stdio transport
var transport = new StdioServerTransport();
await server.ConnectAsync(transport);
Console.WriteLine("Weather MCP Server started");
// Keep the server running until process is terminated
await Task.Delay(-1);
}
private static async Task<WeatherData> GetWeatherDataAsync(string location)
{
// This would normally call a weather API
// Simplified for demonstration
await Task.Delay(100); // Simulate API call
return new WeatherData {
Temperature = 72.5,
Conditions = "Sunny",
Location = location
};
}
}
public class WeatherData
{
public double Temperature { get; set; }
public string Conditions { get; set; }
public string Location { get; set; }
}Dette eksempelet viser samme MCP-server og verktøyregistrering som .NET-eksemplet over, men implementert i Java.
import io.modelcontextprotocol.server.McpServer;
import io.modelcontextprotocol.server.McpToolDefinition;
import io.modelcontextprotocol.server.transport.StdioServerTransport;
import io.modelcontextprotocol.server.tool.ToolExecutionContext;
import io.modelcontextprotocol.server.tool.ToolResponse;
public class WeatherMcpServer {
public static void main(String[] args) throws Exception {
// Create an MCP server
McpServer server = McpServer.builder()
.name("Weather MCP Server")
.version("1.0.0")
.build();
// Register a weather tool
server.registerTool(McpToolDefinition.builder("weatherTool")
.description("Gets current weather for a location")
.parameter("location", String.class)
.execute((ToolExecutionContext ctx) -> {
String location = ctx.getParameter("location", String.class);
// Get weather data (simplified)
WeatherData data = getWeatherData(location);
// Return formatted response
return ToolResponse.content(
String.format("Temperature: %.1f°F, Conditions: %s, Location: %s",
data.getTemperature(),
data.getConditions(),
data.getLocation())
);
})
.build());
// Connect the server using stdio transport
try (StdioServerTransport transport = new StdioServerTransport()) {
server.connect(transport);
System.out.println("Weather MCP Server started");
// Keep server running until process is terminated
Thread.currentThread().join();
}
}
private static WeatherData getWeatherData(String location) {
// Implementation would call a weather API
// Simplified for example purposes
return new WeatherData(72.5, "Sunny", location);
}
}
class WeatherData {
private double temperature;
private String conditions;
private String location;
public WeatherData(double temperature, String conditions, String location) {
this.temperature = temperature;
this.conditions = conditions;
this.location = location;
}
public double getTemperature() {
return temperature;
}
public String getConditions() {
return conditions;
}
public String getLocation() {
return location;
}
}I dette eksemplet viser vi hvordan man bygger en MCP-server i Python. Du får også se to forskjellige måter å lage verktøy på.
#!/usr/bin/env python3
import asyncio
from mcp.server.fastmcp import FastMCP
from mcp.server.transports.stdio import serve_stdio
# Create a FastMCP server
mcp = FastMCP(
name="Weather MCP Server",
version="1.0.0"
)
@mcp.tool()
def get_weather(location: str) -> dict:
"""Gets current weather for a location."""
# This would normally call a weather API
# Simplified for demonstration
return {
"temperature": 72.5,
"conditions": "Sunny",
"location": location
}
# Alternative approach using a class
class WeatherTools:
@mcp.tool()
def forecast(self, location: str, days: int = 1) -> dict:
"""Gets weather forecast for a location for the specified number of days."""
# This would normally call a weather API forecast endpoint
# Simplified for demonstration
return {
"location": location,
"forecast": [
{"day": i+1, "temperature": 70 + i, "conditions": "Partly Cloudy"}
for i in range(days)
]
}
# Instantiate the class to register its tools
weather_tools = WeatherTools()
# Start the server using stdio transport
if __name__ == "__main__":
asyncio.run(serve_stdio(mcp))Dette eksemplet viser opprettelse av MCP-server i JavaScript og hvordan man registrerer to værrelaterte verktøy.
// Using the official Model Context Protocol SDK
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod"; // For parameter validation
// Create an MCP server
const server = new McpServer({
name: "Weather MCP Server",
version: "1.0.0"
});
// Define a weather tool
server.tool(
"weatherTool",
{
location: z.string().describe("The location to get weather for")
},
async ({ location }) => {
// This would normally call a weather API
// Simplified for demonstration
const weatherData = await getWeatherData(location);
return {
content: [
{
type: "text",
text: `Temperature: ${weatherData.temperature}°F, Conditions: ${weatherData.conditions}, Location: ${weatherData.location}`
}
]
};
}
);
// Define a forecast tool
server.tool(
"forecastTool",
{
location: z.string(),
days: z.number().default(3).describe("Number of days for forecast")
},
async ({ location, days }) => {
// This would normally call a weather API
// Simplified for demonstration
const forecast = await getForecastData(location, days);
return {
content: [
{
type: "text",
text: `${days}-day forecast for ${location}: ${JSON.stringify(forecast)}`
}
]
};
}
);
// Helper functions
async function getWeatherData(location) {
// Simulate API call
return {
temperature: 72.5,
conditions: "Sunny",
location: location
};
}
async function getForecastData(location, days) {
// Simulate API call
return Array.from({ length: days }, (_, i) => ({
day: i + 1,
temperature: 70 + Math.floor(Math.random() * 10),
conditions: i % 2 === 0 ? "Sunny" : "Partly Cloudy"
}));
}
// Connect the server using stdio transport
const transport = new StdioServerTransport();
server.connect(transport).catch(console.error);
console.log("Weather MCP Server started");Dette JavaScript-eksempelet viser hvordan man lager en MCP-klient som kobler til en server, sender en prompt og behandler svaret inkludert eventuelle verktøysanrop som ble gjort.
MCP inkluderer flere innebygde konsepter og mekanismer for å håndtere sikkerhet og autorisasjon gjennom hele protokollen:
-
Kontroll av verktøystillatelser
Klienter kan spesifisere hvilke verktøy en modell har lov til å bruke under en økt. Dette sikrer at kun eksplisitt autoriserte verktøy er tilgjengelige, noe som reduserer risikoen for utilsiktede eller usikre operasjoner. Tillatelser kan konfigureres dynamisk basert på brukerpreferanser, organisasjonspolicyer eller interaksjonskontekst. -
Autentisering
Servere kan kreve autentisering før tilgang til verktøy, ressurser eller sensitive operasjoner gis. Dette kan innebære API-nøkler, OAuth-tokens eller andre autentiseringsordninger. Korrekt autentisering sikrer at kun betrodde klienter og brukere kan påkalle serverfunksjoner. -
Validering
Parameter-validering håndheves for alle verktøysanrop. Hvert verktøy definerer forventede typer, formater og begrensninger for sine parametere, og serveren validerer innkommende forespørsler deretter. Dette forhindrer feilaktig eller ondsinnet input fra å nå verktøyimplementasjonene og
Ansvarsfraskrivelse:
Dette dokumentet er oversatt ved bruk av AI-oversettelsestjenesten Co-op Translator. Selv om vi streber etter nøyaktighet, vennligst vær oppmerksom på at automatiske oversettelser kan inneholde feil eller unøyaktigheter. Det opprinnelige dokumentet på originalspråket skal anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.