1~
2**Model Context Protocol (MCP)** este un standard deschis creat de Anthropic care definește cum modelele AI comunică cu instrumente externe, surse de date și servicii. Gândește-te la el ca la "USB-C-ul AI-ului"  -  un conector universal care permite oricărui agent AI să comunice cu orice instrument printr-o interfață standardizată.
3~
4De la lansare, MCP a depășit **97 de milioane de descărcări lunare ale SDK-ului** și a fost adoptat de toți furnizorii majori de AI: Anthropic, OpenAI, Google, Microsoft și Amazon. În acest ghid, vom explora tot ce trebuie să știi pentru a construi cu MCP.
5~
6## De Ce Există MCP
7~
8Înainte de MCP, fiecare aplicație AI trebuia să construiască integrări personalizate pentru fiecare instrument pe care dorea să îl folosească. Vrei ca AI-ul tău să citească fișiere? Scrie cod personalizat. Să interogheze o bază de date? Mai mult cod personalizat. Să posteze pe Slack? Încă o integrare.
9~
10Aceasta a creat o **problemă N×M**: N aplicații AI, fiecare necesitând M integrări personalizate, ducând la efort duplicat și ecosisteme fragmentate.
11~
12```mermaid
13graph TD
14    subgraph "Before MCP (N×M)"
15        A1[AI App 1] --> T1[GitHub Integration]
16        A1 --> T2[Slack Integration]
17        A1 --> T3[DB Integration]
18        A2[AI App 2] --> T4[GitHub Integration]
19        A2 --> T5[Slack Integration]
20        A2 --> T6[DB Integration]
21    end
22```
23~
24MCP rezolvă asta cu un **singur protocol** pe care orice client AI îl poate folosi pentru a comunica cu orice server MCP:
25~
26```mermaid
27graph TD
28    subgraph "With MCP (N+M)"
29        A1[AI App 1] --> MCP[MCP Protocol]
30        A2[AI App 2] --> MCP
31        MCP --> S1[GitHub Server]
32        MCP --> S2[Slack Server]
33        MCP --> S3[DB Server]
34    end
35```
36~
37## Concepte Fundamentale
38~
39MCP are trei primitive fundamentale:
40~
41### 1. Instrumente (Tools)
42Instrumentele sunt funcții pe care AI-ul le poate apela. Ele reprezintă acțiuni precum "creează un fișier", "interoghează o bază de date" sau "trimite un mesaj". Fiecare instrument are un nume, o descriere și un JSON Schema pentru parametrii săi.
43~
44```typescript
45{
46  name: "create_issue",
47  description: "Create a new GitHub issue",
48  inputSchema: {
49    type: "object",
50    properties: {
51      title: { type: "string", description: "Issue title" },
52      body: { type: "string", description: "Issue body" },
53      repo: { type: "string", description: "Repository name" }
54    },
55    required: ["title", "repo"]
56  }
57}
58```
59~
60### 2. Resurse (Resources)
61Resursele sunt date pe care AI-ul le poate citi. Ele reprezintă fișiere, înregistrări din baze de date, răspunsuri API sau orice altă sursă de date. Resursele sunt identificate prin URI-uri.
62~
63```typescript
64{
65  uri: "file:///Users/dev/project/README.md",
66  name: "Project README",
67  mimeType: "text/markdown"
68}
69```
70~
71### 3. Prompts
72Prompt-urile sunt șabloane reutilizabile care ajută la structurarea interacțiunilor. Pot include parametri dinamici și sunt utile pentru standardizarea fluxurilor de lucru comune.
73~
74```typescript
75{
76  name: "code_review",
77  description: "Review code changes for quality and security",
78  arguments: [
79    { name: "diff", description: "The code diff to review", required: true }
80  ]
81}
82```
83~
84## Arhitectură
85~
86MCP urmează o arhitectură client-server:
87~
88```mermaid
89graph LR
90    subgraph "Host Application"
91        Client[MCP Client]
92    end
93~
94    subgraph "MCP Server"
95        Server[Server Process]
96        Server --> Tools[Tools]
97        Server --> Resources[Resources]
98        Server --> Prompts[Prompts]
99    end
100~
101    Client -- "JSON-RPC 2.0\n(stdio or SSE)" --> Server
102```
103~
104- **Gazdă**: Aplicația AI (Claude Desktop, Cursor, aplicația ta personalizată)
105- **Client**: Menține o conexiune 1:1 cu un server MCP
106- **Server**: Expune instrumente, resurse și prompts clientului
107- **Transport**: Comunicarea se face prin JSON-RPC 2.0 peste stdio (local) sau Server-Sent Events (remote)
108~
109## Construirea unui Server MCP
110~
111Hai să construim un server MCP practic care interacționează cu o listă de sarcini stocată într-un fișier JSON.
112~
113### Configurare
114~
115```bash
116mkdir mcp-todo-server && cd mcp-todo-server
117npm init -y
118npm install @modelcontextprotocol/sdk zod
119```
120~
121### Implementarea Serverului
122~
123```typescript
124// src/index.ts
125import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
126import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
127import { z } from "zod";
128import fs from "fs";
129~
130const TODO_FILE = "./todos.json";
131~
132function readTodos(): { id: number; text: string; done: boolean }[] {
133  if (!fs.existsSync(TODO_FILE)) return [];
134  return JSON.parse(fs.readFileSync(TODO_FILE, "utf-8"));
135}
136~
137function writeTodos(todos: { id: number; text: string; done: boolean }[]) {
138  fs.writeFileSync(TODO_FILE, JSON.stringify(todos, null, 2));
139}
140~
141const server = new McpServer({
142  name: "todo-server",
143  version: "1.0.0",
144});
145~
146// Tool: Add a todo
147server.tool(
148  "add_todo",
149  "Add a new todo item",
150  { text: z.string().describe("The todo text") },
151  async ({ text }) => {
152    const todos = readTodos();
153    const newTodo = { id: Date.now(), text, done: false };
154    todos.push(newTodo);
155    writeTodos(todos);
156    return { content: [{ type: "text", text: `Added: "${text}"` }] };
157  }
158);
159~
160// Tool: List todos
161server.tool(
162  "list_todos",
163  "List all todo items",
164  {},
165  async () => {
166    const todos = readTodos();
167    const list = todos
168      .map((t) => `${t.done ? "✅" : "⬜"} [${t.id}] ${t.text}`)
169      .join("\n");
170    return { content: [{ type: "text", text: list || "No todos yet." }] };
171  }
172);
173~
174// Tool: Complete a todo
175server.tool(
176  "complete_todo",
177  "Mark a todo as completed",
178  { id: z.number().describe("The todo ID to complete") },
179  async ({ id }) => {
180    const todos = readTodos();
181    const todo = todos.find((t) => t.id === id);
182    if (!todo) return { content: [{ type: "text", text: "Todo not found." }] };
183    todo.done = true;
184    writeTodos(todos);
185    return { content: [{ type: "text", text: `Completed: "${todo.text}"` }] };
186  }
187);
188~
189// Resource: Current todos as a readable resource
190server.resource(
191  "todos://list",
192  "Current todo list",
193  async () => ({
194    contents: [{
195      uri: "todos://list",
196      mimeType: "application/json",
197      text: JSON.stringify(readTodos(), null, 2),
198    }],
199  })
200);
201~
202// Start the server
203const transport = new StdioServerTransport();
204await server.connect(transport);
205```
206~
207### Configurare
208~
209Pentru a folosi acest server cu Claude Desktop, adaugă-l în configurația ta:
210~
211```json
212{
213  "mcpServers": {
214    "todo": {
215      "command": "npx",
216      "args": ["tsx", "/path/to/mcp-todo-server/src/index.ts"]
217    }
218  }
219}
220```
221~
222## Construirea unui Client MCP
223~
224Poți construi și un client personalizat care se conectează la orice server MCP:
225~
226```typescript
227import { Client } from "@modelcontextprotocol/sdk/client/index.js";
228import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
229~
230const transport = new StdioClientTransport({
231  command: "npx",
232  args: ["tsx", "./src/index.ts"],
233});
234~
235const client = new Client({ name: "my-client", version: "1.0.0" });
236await client.connect(transport);
237~
238// List available tools
239const { tools } = await client.listTools();
240console.log("Available tools:", tools.map((t) => t.name));
241~
242// Call a tool
243const result = await client.callTool({
244  name: "add_todo",
245  arguments: { text: "Write MCP blog post" },
246});
247console.log(result);
248```
249~
250## Servere MCP Populare
251~
252Ecosistemul MCP a crescut rapid. Iată câteva dintre cele mai populare servere:
253~
254| Server | Descriere | Caz de Utilizare |
255|--------|-----------|-----------------|
256| **GitHub** | Creare issues, PR-uri, gestionare repo-uri | Fluxuri de lucru de dezvoltare |
257| **Slack** | Trimitere mesaje, gestionare canale | Comunicare în echipă |
258| **PostgreSQL** | Interogare și gestionare baze de date | Acces la date |
259| **Filesystem** | Citire, scriere și căutare fișiere | Dezvoltare locală |
260| **Puppeteer** | Automatizare browser și scraping | Testare web |
261| **Sentry** | Monitorizare erori și debugging | Suport producție |
262| **Supabase** | Bază de date, auth, stocare | Operațiuni backend |
263~
264## MCP vs A2A (Agent-to-Agent)
265~
266În timp ce MCP gestionează comunicarea **agent-instrument**, protocolul **A2A (Agent-to-Agent)** al Google gestionează comunicarea **agent-agent**. Sunt complementare:
267~
268```mermaid
269graph TD
270    Agent1[Agent 1] -- "A2A Protocol" --> Agent2[Agent 2]
271    Agent1 -- "MCP Protocol" --> Tool1[GitHub MCP Server]
272    Agent2 -- "MCP Protocol" --> Tool2[Database MCP Server]
273```
274~
275- **MCP**: Cum un agent AI folosește instrumente (integrare verticală)
276- **A2A**: Cum agenții AI colaborează între ei (integrare orizontală)
277~
278## Cele Mai Bune Practici
279~
2801. **Menține serverele focalizate**: Un server per domeniu (server GitHub, server Slack, etc.). Nu construi servere monolitice.
2812. **Validează intrările cu Zod**: Validează întotdeauna intrările instrumentelor cu scheme adecvate.
2823. **Gestionează erorile cu grație**: Returnează mesaje de eroare semnificative, nu stack traces.
2834. **Folosește resurse pentru date doar-citire**: Dacă AI-ul trebuie doar să citească date, expune-le ca resursă în loc de instrument.
2845. **Adaugă descrieri adecvate**: Descrierile bune ale instrumentelor și parametrilor ajută AI-ul să înțeleagă când și cum să folosească fiecare instrument.
2856. **Testează cu MCP Inspector**: Folosește `npx @modelcontextprotocol/inspector` pentru a testa serverul interactiv.
286~
287## Începe
288~
289```bash
290# Create a new MCP server from template
291npx @modelcontextprotocol/create-server my-server
292~
293# Test with the MCP Inspector
294npx @modelcontextprotocol/inspector npx tsx ./src/index.ts
295```
296~
297## Concluzie
298~
299MCP a devenit standardul de facto pentru utilizarea instrumentelor AI în 2026. Indiferent dacă construiești agenți AI personalizați, extinzi Claude Code sau creezi integrări pentru platforme existente, înțelegerea MCP este esențială. Protocolul este suficient de simplu pentru a fi învățat într-o după-amiază, dar suficient de puternic pentru a construi fluxuri de lucru AI de nivel producție.
300~
301**Pașii următori:**
302- Explorează [Specificația MCP](https://spec.modelcontextprotocol.io/)
303- Răsfoiește [serverele MCP existente](https://github.com/modelcontextprotocol/servers) pentru inspirație
304- Construiește primul tău server cu SDK-ul TypeScript sau Python
305- Testează-l cu Claude Desktop sau MCP Inspector
306~