GoSuda

O scurtă analiză a MCP host

By snowmerak
views ...

Ce este MCP

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

Despre funcționarea internă

Înainte de a explica funcționarea internă, vom trece în revistă Gemini Function Calling. Gemini Function Calling, la fel ca MCP, permite LLM să apeleze în mod proactiv acțiuni externe. Vă veți întreba de ce am adus în discuție Function Calling. Motivul pentru care l-am adus în discuție este că Function Calling a apărut înaintea MCP și, fiind compatibil prin utilizarea aceleiași OpenAPI schema, am presupus că funcționarea reciprocă va fi similară. Prin urmare, am considerat că explicația Gemini Function Calling, fiind mai detaliată, ar fi utilă și de aceea am adus-o în discuție.

FunctionCalling

Fluxul general este următorul.

  1. Se definește o funcție.
  2. Definiția funcției este trimisă către Gemini împreună cu prompt-ul.
    1. "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."
  3. Gemini solicită apelarea funcției dacă este necesar.
    1. Dacă Gemini consideră necesar, numele și parametrii pentru apelarea funcției sunt transmise apelantului.
    2. Apelantul poate decide dacă să execute sau nu.
      1. Dacă să apeleze și să returneze o valoare validă.
      2. Dacă să returneze date ca și cum ar fi apelat, fără a apela de fapt.
      3. Dacă pur și simplu să ignore.
  4. În timpul procesului de mai sus, Gemini efectuează și solicită acțiuni precum apelarea mai multor funcții simultan sau apelarea din nou după vizualizarea rezultatelor apelului funcției.
  5. În final, se încheie când se obține un răspuns bine structurat.

Acest flux este, în general, în concordanță cu MCP. Acest lucru este explicat similar și în tutorialul MCP. Același lucru este valabil și pentru ollama tools.

Și, din fericire, aceste trei instrumente, ollama tools, MCP și Gemini Function Calling, au o structură de schema atât de similară încât implementarea doar a MCP vă permite să le utilizați pe toate trei.

Ah, și există un dezavantaj pe care îl împărtășesc toate. Deoarece modelul este cel care le execută, dacă modelul pe care îl utilizați nu este într-o stare bună, acesta poate funcționa incorect, cum ar fi să nu apeleze funcția, să o apeleze ciudat sau să lanseze un DOS asupra serverului MCP.

Gazdă MCP în Go

mark3lab's mcphost

În Go există mcphost, care este în curs de dezvoltare de către organizația numită mark3lab.

Modul de utilizare este foarte simplu.

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

După instalare, creați fișierul $HOME/.mcp.json și scrieți următorul conținut.

 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 modelul ollama, ca mai jos. Desigur, înainte de asta, dacă este necesar, descărcați modelul cu ollama pull mistral-small.

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

1mcphost -m ollama:mistral-small

Totuși, rulând astfel, îl puteți utiliza 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 programabil.

Fork mcphost

Așa cum am confirmat deja, mcphost include funcționalități pentru extragerea metadatelor și apelarea funcțiilor utilizând MCP. Prin urmare, sunt necesare părți pentru apelarea llm-ului, gestionarea serverului mcp și gestionarea istoricului mesajelor.

Partea corespunzătoare a fost preluată în Runner-ul din următorul pachet.

 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 părții corespunzătoare separat. Totuși, ele sunt aproape exact ca numele lor.

 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 care vor fi utilizate aici, vă rugăm să verificați fișierul corespunzător. Deoarece vom folosi provider-ul de la ollama, vă rugăm să verificați fișierul corespunzător.

"Felul 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 fișierul corespunzător.

Conținutul este aproximativ următorul.

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

În concluzie

S-a terminat deja?

De fapt, nu sunt multe de spus. Acesta este un articol scris pentru a vă ajuta să înțelegeți cum funcționează Serverul MCP în linii mari. Sper că acest articol v-a fost de ajutor, chiar și puțin, în înțelegerea funcționării gazdei MCP.