Cum să programezi un server MCP

Stoica Paul

o zi ago

În era inteligenței artificiale, eficiența nu înseamnă doar să lucrezi mai rapid, ci să lucrezi mai inteligent, de exemplu printr-un server MCP propriu. Model Context Protocol (MCP) reprezintă o revoluție în modul în care interacționăm cu aplicațiile și serviciile digitale, permițându-ne să ne transformăm activitățile repetitive în comenzi simple, în limbaj natural. În acest articol, vom explora cum poți crea propriul server MCP și cum această tehnologie poate transforma radical fluxul tău de lucru zilnic.

1. Ce este un server MCP și de ce ai avea nevoie de el

Un server MCP este, în esență, un translator inteligent între tine și aplicațiile pe care le folosești zilnic. Imaginează-ți că ai un asistent personal care înțelege perfect ce vrei să faci și știe exact cum să comunice cu toate programele de pe computerul tău.

Principalele avantaje ale MCP serverelor:

Automatizarea prin limbaj natural – în loc să memorezi comenzi complexe sau să navighezi prin interfețe complicate, poți pur și simplu să spui ce vrei să faci;
Integrare universală – un singur server MCP poate conecta multiple aplicații și servicii;
Economisirea timpului – taskurile care înainte necesitau minute sau ore pot fi completate în secunde;
Reducerea erorilor – automatizarea elimină greșelile umane din procesele repetitive.

De exemplu, în loc să deschizi un generator online de hash-uri, să copiezi textul, să selectezi algoritmul și să aștepți rezultatul, poți pur și simplu să scrii: „Generează un hash SHA-256 pentru această parolă”. Server-ul MCP se ocupă de tot restul.

2. Cum funcționează un server MCP în practică

La nivel tehnic, un MCP Server este un program care primește solicitări în format JSON și returnează răspunsuri structurate.

Să luăm ca exemplu un server care generează hash-uri de diferite mărimi:

// server.js
// Simple MCP Server implementation for Windows - No external dependencies needed

class SimpleMCPServer {
  constructor() {
    this.setupStdio();
    this.logToStderr('Simple MCP Random Hash Generator Server starting...');
  }

  setupStdio() {
    process.stdin.setEncoding('utf8');
    process.stdin.on('data', (data) => {
      try {
        const lines = data.trim().split('\n');
        lines.forEach(line => {
          if (line.trim()) {
            this.logToStderr(`Received: ${line}`);
            this.handleMessage(JSON.parse(line));
          }
        });
      } catch (error) {
        this.logToStderr(`Parse error: ${error.message}`);
        this.sendError(null, -32700, 'Parse error');
      }
    });

    process.on('SIGINT', () => {
      this.logToStderr('Server shutting down...');
      process.exit(0);
    });

    process.on('SIGTERM', () => {
      this.logToStderr('Server shutting down...');
      process.exit(0);
    });

    this.logToStderr('MCP Server ready and listening on stdio');
  }

  logToStderr(message) {
    // Log to stderr so it doesn't interfere with MCP protocol on stdout
    console.error(`[MCP Server] ${new Date().toISOString()} - ${message}`);
  }

  handleMessage(message) {
    const { jsonrpc, id, method, params } = message;

    this.logToStderr(`Handling method: ${method} with id: ${id}`);

    if (jsonrpc !== '2.0') {
      return this.sendError(id, -32600, 'Invalid Request - must be JSON-RPC 2.0');
    }

    switch (method) {
      case 'initialize':
        this.handleInitialize(id, params);
        break;

      case 'tools/list':
        this.handleToolsList(id);
        break;

      case 'tools/call':
        this.handleToolCall(id, params);
        break;

      case 'ping':
        this.handlePing(id);
        break;

      default:
        this.sendError(id, -32601, `Method not found: ${method}`);
    }
  }

  handleInitialize(id, params) {
    this.logToStderr('Initializing server...');
    this.sendResponse(id, {
      protocolVersion: '2024-11-05',
      capabilities: {
        tools: {}
      },
      serverInfo: {
        name: 'mcp-server-hash-generator',
        version: '1.0.0'
      }
    });
  }

  handleToolsList(id) {
    this.logToStderr('Listing available tools...');
    this.sendResponse(id, {
      tools: [
        {
          name: 'hash_generator',
          description: 'Generate a random hash of a specified length',
          inputSchema: {
            type: 'object',
            properties: {
              max: {
                type: 'number',
                description: 'Maximum length of the hash',
                minimum: 1
              }
            },
            required: ['max']
          }
        }
      ]
    });
  }

  handleToolCall(id, params) {
    const { name, arguments: args } = params;
    this.logToStderr(`Calling tool: ${name} with args: ${JSON.stringify(args)}`);

    try {
      switch (name) {
        case 'hash_generator':
          this.handleHashGenerator(id, args);
          break;

        default:
          this.sendError(id, -32602, `Unknown tool: ${name}`);
      }
    } catch (error) {
      this.logToStderr(`Tool execution error: ${error.message}`);
      this.sendError(id, -32603, `Tool execution error: ${error.message}`);
    }
  }

  handleHashGenerator(id, args) {
    const { max } = args;

    if (typeof max !== 'number' || max <= 0) {
      return this.sendError(id, -32602, 'Length must be a positive number greater than 0');
    }

    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    let result = '';

    for (let i = 0; i < max; i++) {
      const randomIndex = Math.floor(Math.random() * characters.length);
      result += characters[randomIndex];
    }
    this.logToStderr(`Generated hash: ${result} (length: ${result.length})`);

    this.sendResponse(id, {
      content: [
        {
          type: 'text',
          text: `Generated hash: ${result} (length: ${result.length})`
        }
      ]
    });
  }

  handlePing(id) {
    this.sendResponse(id, {});
  }

  sendResponse(id, result) {
    const response = {
      jsonrpc: '2.0',
      id: id,
      result: result
    };

    this.logToStderr(`Sending response: ${JSON.stringify(response)}`);
    process.stdout.write(JSON.stringify(response) + '\n');
  }

  sendError(id, code, message) {
    const response = {
      jsonrpc: '2.0',
      id: id,
      error: {
        code: code,
        message: message
      }
    };

    this.logToStderr(`Sending error: ${JSON.stringify(response)}`);
    process.stdout.write(JSON.stringify(response) + '\n');
  }
}

// Start the server
new SimpleMCPServer();

Serverul acesta îndeplinește o singură funcție: generează un hash de o anumită formă și un anumit număr de caractere cerut de utilizator.

Acest server simplu poate fi integrat în Visual Studio Code prin extensia Continue, permițându-ți să generezi hash-uri direct din editor, fără să părăsești mediul de dezvoltare.

În exemplul nostru, vom folosi acest server local, în relație directă cu Agentul AI asistent Codestral.

Atunci când cerem agentului AI să genereze un hash, acesta identifică serverul MCP și funcția de generare a hash-urilor și ne întreabă dacă suntem de acord să o folosim.

Agentul AI formatează singur request-ul către server și generează hash-ul dorit.

Pentru acest exemplu am folosit Continue care face posibilă magia MCP în Visual Studio Code. Odată configurat, serverul tău devine disponibil ca o funcționalitate nativă a editorului.

Procesul de integrare include:

Instalarea extensiei Continue din marketplace-ul VS Code
Configurarea server-ului MCP în fișierul de configurare Continue
Testarea funcționalităților prin interfața de chat a extensiei

Imaginează-ți că lucrezi la un proiect de securitate și ai nevoie să verifici rapid hash-urile unor fișiere.

În loc să folosești tool-uri externe, poți pur și simplu să scrii în Continue: „Generează hash SHA-256 pentru această cheie API” și primești imediat rezultatul, direct în editor.

Exemple practice de utilizare:

Generarea rapidă de identificatori unici pentru baze de date;
Verificarea integrității fișierelor în timpul dezvoltării;
Crearea de hash-uri pentru parole în aplicații de testare;
Validarea check-sum-urilor pentru fișiere descărcate;
Generarea de quey-uri SQL pentru interogarea bazelor de date;

3. Exemple concrete de alte servere MCP

Context7 – Specializat pe documentația de programare

Context7 este un exemplu excelent de server MCP specializat care revoluționează modul în care programatorii accesează documentația. În loc să cauți manual prin documentația React, Angular sau oricărei alte tehnologii, poți pur și simplu să întrebi:

„Cum implementez un hook personalizat în React pentru gestionarea stării locale?”

Context7 va extrage informațiile relevante din documentația oficială și îți va oferi exemple concrete, adaptate contextului tău specific de lucru.

Avantajele Context7:

Acces instant la documentația actualizată;
Exemple de cod contextuale;
Explicații personalizate pentru nivelul tău de experiență;
Integrare seamless cu workflow-ul de dezvoltare.

Server MCP WordPress – Gestionarea conținutului prin limbaj natural

Un alt exemplu fascinant este un server MCP pentru WordPress, care transformă gestionarea site-ului într-o conversație naturală. Acest server MCP poate fi integrat în VSC, dar și direct în orice interfață de utilizare a unui asistent AI.

Exemple de comenzi posibile

Tradițional administrarea unui website pe structură WordPress se face din interfața clasică a acestuia. Se adaugă sau se editează articole, se setează categorii de articole sau se adăugă elemente multimedia etc.

Cu server-ul MCP totul trece la un cu totul alt nivel. O comandă posibilă este de exemplu „Creează un articol nou cu titlul ‘Ghid SEO 2024’ și publică-l mâine la ora 10” sau „Actualizează toate plugin-urile și trimite-mi un raport”.

Asistentul AI va accesa lista de comenzi posibile ale serverului MCP și le va alege pe cele mai potrivite pentru a îndeplini toate sarcinile.

Astfel el va adăuga un articol nou și eventual va cere detalii suplimentare despre felul cum trebuie să genereze conținutul acestuia, stilul și informațiile pe care trebuie să le comunice.

Cât de simplu devine acum generarea unui raport cu vânzările unui website printr-o comandă simplă și naturală precum: „Exportă toate comenzile primite în ultima lună într-un fișier CSV”.

Această abordare elimină necesitatea de a naviga prin interfața de administrare WordPress, economisind timp prețios și reducând curba de învățare pentru utilizatorii noi.

4. Construirea propriului server MCP

Crearea unui server MCP personalizat poate părea intimidantă, dar procesul este surprinzător de accesibil. Să luăm ca exemplu serverul nostru de hash-uri:

Pașii principali:

Definirea funcționalităților – Ce vrei să automatizezi?
Structurarea răspunsurilor – Cum vor arăta rezultatele?
Implementarea logicii – Codul care face treaba efectivă
Testarea și integrarea – Verificarea că totul funcționează correct

Considerații importante:

Securitatea – nu procesa niciodată informații sensibile fără validare
Performanța – Serverul trebuie să răspundă rapid pentru o experiență fluidă
Documentația – Descrie clar ce face fiecare funcționalitate
Gestionarea erorilor – Previzualizează și gestionează situațiile neașteptate

Chiar și fără experiență avansată în programare, poți adapta exemple existente și poți crea tool-uri utile pentru nevoile tale specifice.

5. Concluzie: viitorul automatizării inteligente

Serverele MCP reprezintă mult mai mult decât simple tool-uri de automatizare – ele sunt poarta către o nouă paradigmă de interacțiune cu tehnologia. Prin transformarea comenzilor complexe în conversații naturale, acestea democratizează accesul la automatizare pentru oricine, indiferent de nivelul tehnic.

În viitorul apropiat, vom vedea probabil servere MCP pentru aproape orice aplicație sau serviciu digital: de la gestionarea emailurilor și calendarul personal, până la controlul sistemelor smart home sau analiza datelor complexe. Provocarea nu va mai fi să înveți cum să folosești fiecare aplicație în parte, ci să știi să comunici eficient cu asistentul tău digital universal.

Investiția în înțelegerea și utilizarea serverelor MCP astăzi te va poziționa în avangarda productivității de mâine. Începe cu exemple simple, experimentează cu tool-uri existente și, pe măsură ce îți crește încrederea, construiește soluții personalizate pentru provocările tale unice. Viitorul muncii nu este despre înlocuirea oamenilor cu roboți, ci despre împuternicirea oamenilor cu instrumente inteligente care îi ajută să se concentreze pe ceea ce contează cu adevărat: creativitatea, strategia și inovația.