Sedikit Memahami Host MCP
Apa itu MCP?
MCP adalah sebuah protokol yang dikembangkan oleh Anthropic untuk Claude. MCP merupakan singkatan dari Model Context Protocol, yaitu sebuah protokol yang memungkinkan LLM untuk secara aktif meminta tindakan atau sumber daya eksternal. MCP hanyalah sebuah protokol yang secara harfiah memberikan permintaan dan respons, sehingga proses dan eksekusinya harus dilakukan oleh pengembang.
Mengenai Cara Kerja Internal
Sebelum menjelaskan cara kerja internal, mari kita bahas tentang Gemini Function Calling. Gemini Function Calling, sama seperti MCP, memungkinkan LLM untuk secara proaktif memanggil tindakan eksternal. Maka timbul pertanyaan, mengapa Function Calling sengaja dibawa? Alasan sengaja membawanya adalah karena Function Calling muncul lebih dulu daripada MCP, dan karena keduanya menggunakan skema OpenAPI, keduanya kompatibel, dan diasumsikan bahwa tindakan keduanya akan serupa. Oleh karena itu, penjelasan Gemini Function Calling yang relatif lebih rinci, diharapkan dapat membantu.
Alur keseluruhannya adalah sebagai berikut:
- Mendefinisikan fungsi.
- Mengirimkan definisi fungsi ke Gemini bersama dengan prompt.
- "Kirim prompt pengguna beserta deklarasi fungsi ke model. Model menganalisis permintaan dan menentukan apakah panggilan fungsi akan membantu. Jika demikian, model merespons dengan objek JSON terstruktur."
- Jika Gemini memerlukannya, ia meminta panggilan fungsi.
- Jika Gemini memerlukannya, pemanggil menerima nama dan parameter untuk panggilan fungsi.
- Pemanggil dapat memutuskan apakah akan mengeksekusi atau tidak.
- Apakah akan memanggil dan mengembalikan nilai yang sah
- Apakah akan mengembalikan data seolah-olah dipanggil tanpa memanggilnya
- Apakah akan mengabaikannya begitu saja
- Gemini melakukan dan meminta tindakan seperti memanggil beberapa fungsi sekaligus dalam proses di atas, atau memanggil fungsi lagi setelah melihat hasilnya.
- Akhirnya, jika jawaban yang teratur muncul, proses berakhir.
Alur ini secara umum konsisten dengan MCP. Hal ini juga dijelaskan serupa dalam tutorial MCP. Ini juga mirip dengan ollama tools.
Dan syukurlah, ketiga alat ini, ollama tools, MCP, dan Gemini Function Calling, memiliki struktur skema yang hampir sama, sehingga dengan mengimplementasikan satu MCP saja, Anda dapat menggunakannya di ketiga tempat tersebut.
Oh, dan ada kelemahan yang dimiliki oleh semuanya. Pada akhirnya, model yang menjalankannya, jadi jika model yang Anda gunakan tidak dalam kondisi baik, model dapat melakukan kesalahan seperti tidak memanggil fungsi, memanggilnya secara aneh, atau melakukan serangan DOS ke server MCP.
Host MCP dalam Go
mcphost dari mark3lab
Di Go, ada mcphost yang sedang dikembangkan oleh organisasi bernama mark3lab.
Cara penggunaannya sangat sederhana.
1go install github.com/mark3labs/mcphost@latest
Setelah instalasi, buat file $HOME/.mcp.json
dan tuliskan sebagai berikut:
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}
Kemudian jalankan dengan model ollama sebagai berikut:
Tentu saja, sebelum itu, jika perlu, ambil model dengan ollama pull mistral-small
.
Meskipun secara umum direkomendasikan claude atau qwen2.5, untuk saat ini saya merekomendasikan mistral-small.
1mcphost -m ollama:mistral-small
Namun, jika dijalankan seperti ini, hanya dapat digunakan dalam mode tanya jawab di lingkungan CLI.
Oleh karena itu, kami akan memodifikasi kode mcphost
ini agar dapat beroperasi lebih terprogram.
Fork mcphost
Seperti yang sudah dikonfirmasi, mcphost
menyertakan fungsi untuk mengekstrak metadata dan memanggil fungsi menggunakan MCP. Oleh karena itu, diperlukan bagian untuk memanggil LLM, bagian untuk menangani server MCP, dan bagian untuk mengelola riwayat pesan.
Bagian yang relevan yang diambil adalah Runner
dari paket berikut:
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}
Kami tidak akan membahas deklarasi internal bagian ini secara terpisah. Namun, hampir sama dengan namanya.
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}
Untuk mcpClients
dan tools
yang akan digunakan di sini, silakan lihat file ini.
Untuk provider
yang akan menggunakan ollama, silakan lihat file ini.
Hidangan utamanya adalah metode 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.ContentBlock{
149 Role: "user",
150 Content: toolResults,
151 })
152
153 return r.Run(ctx, "")
154 }
155
156 return message.GetContent(), nil
157}
Kode itu sendiri adalah hasil penggabungan sebagian kode dari file ini.
Isinya secara garis besar adalah sebagai berikut:
- Mengirimkan daftar alat beserta prompt untuk meminta eksekusi atau pembuatan respons.
- Jika respons dihasilkan, rekursi dihentikan dan dikembalikan.
- Jika LLM meninggalkan permintaan eksekusi alat, host akan memanggil Server MCP.
- Menambahkan respons ke riwayat dan kembali ke langkah 1.
Penutup
Sudah selesai?
Sejujurnya, tidak banyak yang bisa saya sampaikan. Ini adalah artikel yang ditulis untuk membantu Anda memahami bagaimana Server MCP beroperasi secara umum. Saya berharap artikel ini dapat sedikit membantu Anda memahami operasi host MCP.