GoSuda

Înțelegerea mai aprofundată a host-ului MCP

By snowmerak
views ...

Ce este MCP

MCP este un protocol dezvoltat de Anthropic pentru claude. MCP este acronimul pentru Model Context Protocol și este un protocol care permite unui LLM să solicite în mod activ acțiuni sau resurse externe. Deoarece MCP este, literal, doar un protocol pentru solicitări și răspunsuri, procesul și execuția trebuie implementate de către dezvoltator.

Despre funcționarea internă

Înainte de a explica funcționarea internă, vom menționa Gemini Function Calling. Gemini Function Calling, la fel ca MCP, permite unui LLM să inițieze în mod autonom apeluri către acțiuni externe. Ați putea întreba de ce am adus în discuție Function Calling. Motivul este că Function Calling a apărut înaintea MCP și, deoarece ambele utilizează aceeași schemă OpenAPI, sunt compatibile, sugerând o similaritate în modul lor de operare. Prin urmare, am considerat că explicațiile mai detaliate ale Gemini Function Calling ar fi utile.

FunctionCalling

Fluxul general este următorul:

  1. Se definește o funcție.
  2. Definiția funcției este transmisă către Gemini împreună cu promptul.
    1. "Se trimite promptul utilizatorului împreună cu declarația(ele) de funcție către model. Acesta analizează solicitarea și determină dacă un apel de funcție ar fi util. Dacă da, răspunde cu un obiect JSON structurat."
  3. Dacă este necesar, Gemini solicită un apel de funcție.
    1. Atunci când este necesar, apelantul primește numele și parametrii pentru apelul de funcție de la Gemini.
    2. Apelantul poate decide dacă să execute sau nu.
      1. Să execute și să returneze o valoare validă.
      2. Să returneze date ca și cum ar fi fost apelată, fără a o executa.
      3. Să ignore pur și simplu.
  4. În acest proces, Gemini efectuează și solicită acțiuni precum apelarea mai multor funcții simultan sau apelarea ulterioară a unei funcții pe baza rezultatului anterior.
  5. Procesul se încheie atunci când se obține un răspuns bine structurat.

Acest flux este în general în concordanță cu MCP. Acest lucru este explicat în mod similar și în tutorialul MCP. De asemenea, este similar cu ollama tools.

Și, din fericire, aceste trei instrumente—ollama tools, MCP și Gemini Function Calling—au o structură de schemă atât de similară încât implementarea doar a MCP permite utilizarea în toate cele trei contexte.

Ah, și există un dezavantaj comun. Deoarece modelul este cel care inițiază execuția, dacă modelul pe care îl utilizați nu este într-o stare optimă, acesta poate funcționa defectuos, de exemplu, nu apelează funcția, o apelează ciudat sau efectuează atacuri DOS asupra serverului MCP.

Gazdă MCP în Go

mcphost de la mark3lab

În Go, există mcphost, dezvoltat de organizația mark3lab.

Utilizarea este extrem de simplă.

1go install github.com/mark3labs/mcphost@latest

După instalare, creați fișierul $HOME/.mcp.json și scrieți următoarele:

 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}

Apoi, rulați-l cu un model ollama, ca mai jos. Desigur, dacă este necesar, mai întâi descărcați modelul cu ollama pull mistral-small.

Deși se recomandă în mod implicit claude sau qwen2.5, eu recomand mistral-small pentru moment.

1mcphost -m ollama:mistral-small

Totuși, rulat astfel, poate fi utilizat doar într-un mediu CLI sub formă de întrebări și răspunsuri. Prin urmare, vom modifica codul acestui mcphost pentru a-l face să funcționeze într-un mod mai programatic.

Fork-ul mcphost

Așa cum s-a confirmat deja, mcphost include funcționalitatea de a extrage metadate și de a apela funcții folosind MCP. Prin urmare, sunt necesare componente pentru apelarea LLM-ului, gestionarea serverului MCP și gestionarea istoricului mesajelor.

Runner-ul din pachetul următor preia aceste părți:

 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}

Nu vom examina declarațiile interne ale acestei părți. Totuși, ele sunt aproape exact ce sugerează numele.

 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}

Pentru mcpClients și tools utilizate aici, vă rugăm să consultați acest fișier. Pentru provider, deoarece vom folosi cel de la ollama, vă rugăm să consultați acest fișier.

Piesa principală este metoda Run.

  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}

Codul în sine este o compilație a unor părți din acest fișier.

Conținutul este, în linii mari, următorul:

  1. Se trimite promptul împreună cu lista de instrumente pentru a solicita fie execuția, fie generarea unui răspuns.
  2. Dacă se generează un răspuns, se oprește recursivitatea și se returnează rezultatul.
  3. Dacă LLM-ul lasă o solicitare de execuție a unui instrument, gazda apelează MCP Server.
  4. Răspunsul este adăugat la istoric și se revine la pasul 1.

În încheiere

Deja sfârșitul?

De fapt, nu sunt multe de spus. Acest articol a fost scris pentru a vă ajuta să înțelegeți, în linii mari, cum funcționează un MCP Server. Sper că acest articol v-a fost de mic ajutor în înțelegerea funcționării gazdei MCP.