Litt forståelse av MCP host
Hva er MCP?
MCP er en protokoll utviklet av Anthropic for Claude. MCP, som er en forkortelse for Model Context Protocol, er en protokoll som gjør det mulig for en LLM å aktivt be om eksterne operasjoner eller ressurser. Siden MCP bokstavelig talt bare er en protokoll som gir forespørsler og svar, må utvikleren håndtere prosessen og utførelsen.
Om intern funksjonalitet
Før jeg forklarer den interne funksjonaliteten, vil jeg ta for meg Gemini Function Calling. Gemini Function Calling gjør, i likhet med MCP, at LLM kan initiere eksterne operasjoner. Du lurer kanskje på hvorfor jeg spesifikt har tatt med Function Calling. Grunnen til at jeg tok den med er at Function Calling kom ut før MCP, og den bruker samme OpenAPI-skjema, noe som gjør dem kompatible, og jeg antok at deres interne funksjonalitet ville være lik. Derfor er Gemini Function Callings forklaring mer detaljert, og jeg tok den med i håp om at den ville være nyttig.
Den overordnede flyten er som følger:
- Definerer funksjonen.
- Sender funksjonsdefinisjonen til Gemini sammen med prompten.
- "Send user prompt along with the function declaration(s) to the model. It analyzes the request and determines if a function call would be helpful. If so, it responds with a structured JSON object."
- Gemini ber om et funksjonskall om nødvendig.
- Hvis Gemini trenger det, mottar den kallernavnet og parametrene for funksjonskallet.
- Kalleren kan bestemme om den skal utføre eller ikke.
- Om den skal kalle og returnere en gyldig verdi.
- Om den skal returnere data som om den ble kalt, uten å kalle den.
- Om den bare skal ignoreres.
- I prosessen ovenfor utfører og ber Gemini om handlinger som å kalle flere funksjoner samtidig, eller kalle en funksjon og deretter kalle den igjen basert på resultatet.
- Til slutt avsluttes den når et ryddig svar er oppnådd.
Denne flyten er generelt i tråd med MCP. Dette er også forklart på lignende måte i MCPs veiledning. Dette gjelder også for ollama tools.
Og heldigvis er skjema-strukturen for disse tre verktøyene – ollama tools, MCP og Gemini Function Calling – såpass delt at man kan bruke MCP alene for alle tre.
Og så er det en felles ulempe. Siden det til syvende og sist er modellen som utfører, kan modellen, hvis den er i dårlig stand, enten ikke kalle funksjonen, kalle den på en merkelig måte, eller utføre feil som å sende en DOS til MCP-serveren.
MCP-vert i Go
mark3lab's mcphost
I Go finnes det mcphost, som er under utvikling av organisasjonen mark3lab.
Bruken er svært enkel.
1go install github.com/mark3labs/mcphost@latest
Etter installasjon, opprett $HOME/.mcp.json
-filen og skriv inn følgende:
1{
2 "mcpServers": {
3 "sqlite": {
4 "command": "uvx",
5 "args": [
6 "mcp-server-sqlite",
7 "--db-path",
8 "/tmp/foo.db"
9 ]
10 },
11 "filesystem": {
12 "command": "npx",
13 "args": [
14 "-y",
15 "@modelcontextprotocol/server-filesystem",
16 "/tmp"
17 ]
18 }
19 }
20}
Og kjør den deretter med en ollama-modell som følger.
Selvfølgelig, hvis nødvendig, hent modellen med ollama pull mistral-small
først.
Selv om claude eller qwen2.5 anbefales som standard, anbefaler jeg mistral-small for øyeblikket.
1mcphost -m ollama:mistral-small
Men hvis den kjøres på denne måten, kan den bare brukes i et CLI-miljø for spørsmål og svar.
Derfor vil vi endre koden for mcphost
slik at den kan operere på en mer programmerbar måte.
mcphost Fork
Som allerede bekreftet, inneholder mcphost
funksjonalitet for å trekke ut metadata og kalle funksjoner ved hjelp av MCP. Derfor er det nødvendig med deler for å kalle LLM, håndtere MCP-serveren og administrere meldingshistorikken.
Runner
i den følgende pakken er den hentede delen.
1package runner
2
3import (
4 "context"
5 "encoding/json"
6 "fmt"
7 "log"
8 "strings"
9 "time"
10
11 mcpclient "github.com/mark3labs/mcp-go/client"
12 "github.com/mark3labs/mcp-go/mcp"
13
14 "github.com/mark3labs/mcphost/pkg/history"
15 "github.com/mark3labs/mcphost/pkg/llm"
16)
17
18type Runner struct {
19 provider llm.Provider
20 mcpClients map[string]*mcpclient.StdioMCPClient
21 tools []llm.Tool
22
23 messages []history.HistoryMessage
24}
Jeg vil ikke se på den interne deklarasjonen av den tilhørende delen separat. Men den er nesten bokstavelig talt navnet.
1func NewRunner(systemPrompt string, provider llm.Provider, mcpClients map[string]*mcpclient.StdioMCPClient, tools []llm.Tool) *Runner {
2 return &Runner{
3 provider: provider,
4 mcpClients: mcpClients,
5 tools: tools,
6 messages: []history.HistoryMessage{
7 {
8 Role: "system",
9 Content: []history.ContentBlock{{
10 Type: "text",
11 Text: systemPrompt,
12 }},
13 },
14 },
15 }
16}
For mcpClients
og tools
som skal brukes her, vennligst sjekk denne filen.provider
vil bruke ollamas, så sjekk denne filen.
Hovedretten er Run
-metoden.
1func (r *Runner) Run(ctx context.Context, prompt string) (string, error) {
2 if len(prompt) != 0 {
3 r.messages = append(r.messages, history.HistoryMessage{
4 Role: "user",
5 Content: []history.ContentBlock{{
6 Type: "text",
7 Text: prompt,
8 }},
9 })
10 }
11
12 llmMessages := make([]llm.Message, len(r.messages))
13 for i := range r.messages {
14 llmMessages[i] = &r.messages[i]
15 }
16
17 const initialBackoff = 1 * time.Second
18 const maxRetries int = 5
19 const maxBackoff = 30 * time.Second
20
21 var message llm.Message
22 var err error
23 backoff := initialBackoff
24 retries := 0
25 for {
26 message, err = r.provider.CreateMessage(
27 context.Background(),
28 prompt,
29 llmMessages,
30 r.tools,
31 )
32 if err != nil {
33 if strings.Contains(err.Error(), "overloaded_error") {
34 if retries >= maxRetries {
35 return "", fmt.Errorf(
36 "claude is currently overloaded. please wait a few minutes and try again",
37 )
38 }
39
40 time.Sleep(backoff)
41 backoff *= 2
42 if backoff > maxBackoff {
43 backoff = maxBackoff
44 }
45 retries++
46 continue
47 }
48
49 return "", err
50 }
51
52 break
53 }
54
55 var messageContent []history.ContentBlock
56
57 var toolResults []history.ContentBlock
58 messageContent = []history.ContentBlock{}
59
60 if message.GetContent() != "" {
61 messageContent = append(messageContent, history.ContentBlock{
62 Type: "text",
63 Text: message.GetContent(),
64 })
65 }
66
67 for _, toolCall := range message.GetToolCalls() {
68 input, _ := json.Marshal(toolCall.GetArguments())
69 messageContent = append(messageContent, history.ContentBlock{
70 Type: "tool_use",
71 ID: toolCall.GetID(),
72 Name: toolCall.GetName(),
73 Input: input,
74 })
75
76 parts := strings.Split(toolCall.GetName(), "__")
77
78 serverName, toolName := parts[0], parts[1]
79 mcpClient, ok := r.mcpClients[serverName]
80 if !ok {
81 continue
82 }
83
84 var toolArgs map[string]interface{}
85 if err := json.Unmarshal(input, &toolArgs); err != nil {
86 continue
87 }
88
89 var toolResultPtr *mcp.CallToolResult
90 req := mcp.CallToolRequest{}
91 req.Params.Name = toolName
92 req.Params.Arguments = toolArgs
93 toolResultPtr, err = mcpClient.CallTool(
94 context.Background(),
95 req,
96 )
97
98 if err != nil {
99 errMsg := fmt.Sprintf(
100 "Error calling tool %s: %v",
101 toolName,
102 err,
103 )
104 log.Printf("Error calling tool %s: %v", toolName, err)
105
106 toolResults = append(toolResults, history.ContentBlock{
107 Type: "tool_result",
108 ToolUseID: toolCall.GetID(),
109 Content: []history.ContentBlock{{
110 Type: "text",
111 Text: errMsg,
112 }},
113 })
114
115 continue
116 }
117
118 toolResult := *toolResultPtr
119
120 if toolResult.Content != nil {
121 resultBlock := history.ContentBlock{
122 Type: "tool_result",
123 ToolUseID: toolCall.GetID(),
124 Content: toolResult.Content,
125 }
126
127 var resultText string
128 for _, item := range toolResult.Content {
129 if contentMap, ok := item.(map[string]interface{}); ok {
130 if text, ok := contentMap["text"]; ok {
131 resultText += fmt.Sprintf("%v ", text)
132 }
133 }
134 }
135
136 resultBlock.Text = strings.TrimSpace(resultText)
137
138 toolResults = append(toolResults, resultBlock)
139 }
140 }
141
142 r.messages = append(r.messages, history.HistoryMessage{
143 Role: message.GetRole(),
144 Content: messageContent,
145 })
146
147 if len(toolResults) > 0 {
148 r.messages = append(r.messages, history.HistoryMessage{
149 Role: "user",
150 Content: toolResults,
151 })
152
153 return r.Run(ctx, "")
154 }
155
156 return message.GetContent(), nil
157}
Selve koden er sammensatt av deler av koden fra denne filen.
Innholdet er omtrent som følger:
- Sender en liste over verktøy sammen med prompten for å be om utførelse eller generering av svar.
- Hvis et svar genereres, stoppes rekursjonen og svaret returneres.
- Hvis LLM ber om verktøyutførelse, kaller verten MCP-serveren.
- Svaret legges til historikken, og prosessen går tilbake til trinn 1.
Avslutning
Allerede slutt?
Jeg har faktisk ikke så mye å si. Denne artikkelen er skrevet for å hjelpe deg med å forstå hvordan MCP Server opererer. Jeg håper denne artikkelen har vært til nytte for deg i å forstå hvordan MCP-verten fungerer.