Το MCP με βάση την προδιαγραφή: τι είναι πραγματικά ένας server

Πριν από το wire, η αριθμητική. Έχετε $N$ AI εφαρμογές και $M$ πράγματα στα οποία θα έπρεπε να μπορούν να φτάσουν — ένα ημερολόγιο, ένα ticket tracker, μια βάση δεδομένων αποθήκης, ένα εργαλείο σχεδιασμού. Χωρίς κοινό συμβόλαιο, κάποιος γράφει $N \times M$ integrations, και καθένα από αυτά είναι ένα schema συν ένα endpoint συν μια ιστορία authentication συν ένα βάρος συντήρησης. Με ένα κοινό συμβόλαιο, ο vendor του εργαλείου γράφει έναν server, ο vendor της εφαρμογής γράφει έναν client, και το σύνολο είναι $N + M$.

Δεν είναι νέα παρατήρηση, και η προδιαγραφή λέει ποιανού ιδέα ήταν:

Το MCP αντλεί κάποια έμπνευση από το Language Server Protocol, το οποίο τυποποιεί τον τρόπο προσθήκης υποστήριξης για γλώσσες προγραμματισμού σε ένα ολόκληρο οικοσύστημα εργαλείων ανάπτυξης. Με παρόμοιο τρόπο, το MCP τυποποιεί τον τρόπο ενσωμάτωσης πρόσθετου context και εργαλείων στο οικοσύστημα των AI εφαρμογών.¹

Πάρτε αυτή τη σύγκριση κυριολεκτικά, όχι ως φιλοφρόνηση. Πριν από εκείνο το πρωτόκολλο, η υποστήριξη μιας γλώσσας σε έναν editor σήμαινε ένα plugin ανά editor· μετά, μια ομάδα γλώσσας έστελνε έναν server και κάθε editor το αποκτούσε. Το μέτρο της επιτυχίας δεν ήταν η κομψότητα· ήταν ότι ο αριθμός των integrations σταμάτησε να πολλαπλασιάζεται. Το ίδιο ισχύει εδώ: η αξία βρίσκεται στον αριθμό των υλοποιήσεων, όχι στον σχεδιασμό. Ένα πρωτόκολλο που το μιλούν δύο προϊόντα είναι απλώς μορφή δεδομένων με πρόσθετη τελετουργία.

Τα μηνύματα MCP είναι JSON-RPC 2.0. Ένα request είναι ένα object με jsonrpc, ένα id, ένα method και προαιρετικό params· ένα response μεταφέρει το ίδιο id και είτε result είτε error· ένα notification είναι request χωρίς id και δεν παίρνει απάντηση. Η προδιαγραφή προσθέτει τρεις περιορισμούς από πάνω: το id πρέπει να είναι string ή number και δεν πρέπει να είναι null, δεν πρέπει να συγκρούεται με άλλο request που είναι ακόμη σε εξέλιξη, και κάθε result πρέπει να μεταφέρει πεδίο resultType.²

Στο stdio transport — εκείνο που χρησιμοποίησε η παραπάνω εντολή — ο κανόνας framing είναι μία γραμμή ανά μήνυμα:

Τα μηνύματα οριοθετούνται από newlines και MUST NOT περιέχουν embedded newlines. […] Ο server MUST NOT γράφει τίποτα στο stdout του που να μην είναι έγκυρο MCP message.³

Αυτή η τελευταία ρήτρα είναι ο πιο συνηθισμένος τρόπος με τον οποίο σπάει ένας χειροποίητος server, και σπάει σιωπηλά: ένα stray console.log, ένα progress bar, ένα deprecation warning από dependency, και ο line parser του client πέφτει πάνω σε κάτι που δεν είναι JSON. Η διέξοδος βρίσκεται στην ίδια ενότητα — ο server may γράφει ό,τι θέλει στο stderr, και ο client should not το αντιμετωπίζει ως σφάλμα. Ο reference server παραπάνω τυπώνει Starting default (STDIO) server... σε κάθε εκκίνηση, στο stderr, γι’ αυτό και το pipe εξακολουθούσε να λειτουργεί.

Το άλλο τυπικό transport είναι το Streamable HTTP: κάθε μήνυμα είναι ένα POST σε ένα μοναδικό endpoint, και η απάντηση είναι είτε JSON object είτε request-scoped stream από Server-Sent Events — το wire format που το Κεφάλαιο 14 έκανε parse με το χέρι. Τα semantics είναι ίδια και στα δύο, επειδή ένα transport είναι binding: ορίζει framing και delivery, όχι νόημα.⁴

Η παραπάνω εντολή έστειλε tools/list και τίποτε άλλο. Με την τρέχουσα αναθεώρηση αυτό το request είναι malformed, και ένας conformant server πρέπει να το απορρίψει.

Από τις 2026-07-28, το MCP είναι stateless protocol, και η προδιαγραφή το δηλώνει χωρίς υπεκφυγές:

Το Model Context Protocol (MCP) είναι stateless protocol: όλες οι πληροφορίες που χρειάζονται για την επεξεργασία ενός request περιέχονται στο ίδιο το request. Ένας server επεξεργάζεται κάθε request ανεξάρτητα· δεν πρέπει να συνάγεται κανένα state από προηγούμενα requests, ακόμη και από εκείνα στην ίδια connection ή στο ίδιο stream.²

Άρα κάθε request μεταφέρει τη δική του protocol version και τα δικά του client capabilities, μέσα σε ένα reserved object _meta μέσα στο params. Δύο από αυτά τα πεδία απαιτούνται σε κάθε μεμονωμένο request· request που λείπει οποιοδήποτε από τα δύο είναι malformed και ο server must απαντήσει -32602:²

Γραμμένο πλήρως, ένα σωστό tools/list είναι αυτό — και είναι η τελευταία φορά που αυτό το κεφάλαιο δείχνει τα metadata ολόκληρα, επειδή βρίσκονται σε κάθε request από εδώ και πέρα:

{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{"_meta":{
  "io.modelcontextprotocol/protocolVersion":"2026-07-28",
  "io.modelcontextprotocol/clientCapabilities":{"elicitation":{"form":{}}},
  "io.modelcontextprotocol/clientInfo":{"name":"bare-hands","version":"0.0.1"}}}}

Το capability object είναι η διαπραγμάτευση. Δεν υπάρχει πλέον ξεχωριστό βήμα negotiation: ο client δηλώνει τι μπορεί να κάνει σε κάθε request, ο server δηλώνει τι μπορεί να κάνει στο result, και καμία πλευρά δεν μπορεί να χρησιμοποιήσει feature που η άλλη δεν έχει δηλώσει. Ένας server που χρειάζεται capability που ο client δεν δήλωσε must απαντήσει -32021 και να ονομάσει το missing capability στο data.requiredCapabilities. Ένας server που δεν μιλά το requested version must απαντήσει -32022 και να παραθέσει τα versions που μιλά.²

Οι clients που θέλουν την απάντηση εκ των προτέρων μπορούν να τη ζητήσουν: το server/discover είναι mandatory RPC που επιστρέφει supported versions, capabilities, identity και ένα προαιρετικό block instructions σε ένα round trip.⁵ Το να το καλέσετε είναι προαιρετικό. Το να το υλοποιήσετε δεν είναι.

Η εντολή λειτούργησε. Με την τρέχουσα αναθεώρηση δεν θα έπρεπε, και ο λόγος που λειτούργησε αξίζει μια μέτρηση αντί για μια παράγραφο, επειδή είναι η κατάσταση ολόκληρου του οικοσυστήματος σε μία γραμμή.

Probe τον reference server με τον τρόπο που η προδιαγραφή λέει σε έναν σύγχρονο client να κάνει probe:

echo '{"jsonrpc":"2.0","id":1,"method":"server/discover","params":{"_meta":{
  "io.modelcontextprotocol/protocolVersion":"2026-07-28",
  "io.modelcontextprotocol/clientCapabilities":{}}}}' \
  | npx @modelcontextprotocol/server-everything stdio

{"jsonrpc":"2.0","id":1,"error":{"code":-32601,"message":"Method not found"}}

Αυτό είναι το τρίτο branch του κανόνα compatibility: ένα DiscoverResult σημαίνει modern, ένα αναγνωρισμένο modern error σημαίνει modern-but-wrong-version, και οτιδήποτε άλλο — συμπεριλαμβανομένου του -32601 — σημαίνει legacy, οπότε κάντε fall back στο initialize handshake.³ Κάντε λοιπόν αυτό, ζητώντας την τρέχουσα αναθεώρηση:

→ {"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2026-07-28",
   "capabilities":{},"clientInfo":{"name":"bare-hands","version":"0.0.1"}}}

← {"result":{"protocolVersion":"2025-11-25","capabilities":{"tools":{"listChanged":true},
   "prompts":{"listChanged":true},"resources":{"subscribe":true,"listChanged":true},
   "logging":{},"tasks":{…},"completions":{}},"serverInfo":{"name":"mcp-servers/everything",
   "title":"Everything Reference Server","version":"2.0.0"},"instructions":"…"}}

Ο client ζήτησε 2026-07-28 και ο server απάντησε 2025-11-25. Στις 7 Σεπτεμβρίου 2026, ο official reference server — npm package @modelcontextprotocol/server-everything, version 2026.8.31, δημοσιευμένο στις 31 Αυγούστου 2026 — δεν υλοποιεί την τρέχουσα αναθεώρηση. Ούτε, με βάση τις ημερομηνίες, το TypeScript SDK πάνω στο οποίο έχει χτιστεί: το release 1.30.0 βγήκε στις 27 Ιουλίου 2026, την προηγούμενη ημέρα από την αναθεώρηση.

Διαβάστε τη συνέπεια, όχι το κουτσομπολιό. Σχεδόν όλα όσα έχουν γραφτεί για το MCP περιγράφουν ένα πρωτόκολλο με initialize handshake, session, ένα request roots/list που στέλνει ο server στον client, και HTTP+SSE transport. Και τα τέσσερα έχουν φύγει ή φεύγουν. Όταν διαβάζετε οτιδήποτε για MCP, συμπεριλαμβανομένης αυτής της σελίδας, το πρώτο πράγμα που πρέπει να ψάχνετε είναι αριθμός αναθεώρησης.

Και ο λόγος που η πρώτη εντολή λειτούργησε δηλώνεται στην προδιαγραφή ως κίνδυνος, όχι ως feature:

ορισμένοι legacy servers δεν επικυρώνουν ότι ένα request φτάνει μετά το initialize και θα επεξεργάζονταν μια era-ambiguous method (όπως tools/call) με legacy semantics. Το probing δίνει deterministic failure αντ’ αυτού.³

Μετρημένο: η αποστολή tools/list σε εκείνον τον server χωρίς κανένα handshake επιστρέφει ολόκληρο τον κατάλογο. Μια method που θα έπρεπε να είχε απορριφθεί εξυπηρετήθηκε, και αυτός είναι ακριβώς ο λόγος που η προδιαγραφή λέει να κάνετε probe πρώτα με server/discover ακόμη κι όταν υποστηρίζετε μόνο modern versions.

Το MCP έχει τρία μέρη, και η διάκριση ανάμεσα στα πρώτα δύο είναι εκείνη που οι περισσότεροι συμπτύσσουν:

Server. Ένα process ή μια υπηρεσία που εκθέτει resources, tools και prompts. Μπορεί να είναι local ή remote, λειτουργεί ανεξάρτητα, και όλη του η δουλειά είναι ένας εστιασμένος τομέας.⁶

Ο κανόνας «ακριβώς ένας server» δεν είναι λογιστική. Είναι αυτό που κάνει υλοποιήσιμη την παρακάτω αρχή σχεδιασμού, και αυτή είναι η πρόταση που πρέπει να πάρετε από την προδιαγραφή αν πάρετε μόνο μία:

Οι servers δεν πρέπει να μπορούν να διαβάσουν όλη τη συζήτηση ούτε να «βλέπουν μέσα» σε άλλους servers. Οι servers λαμβάνουν μόνο τις απαραίτητες contextual πληροφορίες. Το πλήρες conversation history μένει στον host. Κάθε server διατηρεί isolation. Οι cross-server interactions ελέγχονται από τον host.⁶

Αυτό ανατρέπει το mental model με το οποίο φτάνουν οι περισσότεροι. Ένας weather server που συνδέετε στον assistant σας δεν βλέπει τι ρωτήσατε. Βλέπει ένα tools/call με τα arguments που επέλεξε το μοντέλο, και τίποτε άλλο — όχι τα προηγούμενα turns, όχι το system prompt σας, όχι τα αποτελέσματα που επέστρεψε ο calendar server πριν από λίγο. Αν δύο servers πρέπει να συνεργαστούν, ο host μεταφέρει μια τιμή από τον έναν στον άλλον, σκόπιμα, επειδή το ζήτησε το μοντέλο. Γι’ αυτό και το isolation είναι το security property πάνω στο οποίο στηρίζεται το Κεφάλαιο 30: ένας compromised server έχει μικρή, ορισμένη blast radius, και η διεύρυνσή της απαιτεί τη συνεργασία του host.

Η πρώτη εντολή ζήτησε από εκείνον τον server tools και πήρε δεκατρία. Ρωτήστε τον τις άλλες δύο ερωτήσεις και απαντά κι εκείνες: το resources/list επιστρέφει επτά, το prompts/list επιστρέφει τέσσερα. Κανένα τους δεν εμφανίστηκε, επειδή τίποτα δεν το ζήτησε. Αυτό μας φέρνει στη διδακτική ραχοκοκαλιά του MCP, που βρίσκεται στην προδιαγραφή ως ένας πίνακας τον οποίο σχεδόν κανείς δεν παραθέτει:

Όχι «τρεις τρόποι να εκθέσετε ένα capability». Τρεις απαντήσεις στο ποιος αποφασίζει ότι αυτό συμβαίνει. Το μοντέλο αποφασίζει να καλέσει ένα tool. Η εφαρμογή αποφασίζει να προσαρτήσει ένα resource. Ο άνθρωπος αποφασίζει να εκτελέσει ένα prompt. Αν το καταλάβετε λάθος, το feature εξακολουθεί να λειτουργεί, αλλά λειτουργεί τη λάθος στιγμή και για τον λάθος λόγο.

Ο πιο καθαρός τρόπος να το νιώσετε είναι ένα ημερολόγιο. Εδώ είναι ένας server που εκθέτει το ίδιο ημερολόγιο τρεις φορές, μία ως κάθε primitive, σε εκατό γραμμές απλού Node χωρίς dependencies:

const TOOL = {
  name: "create_event",
  description: "Create a calendar event. Writes to the calendar.",
  inputSchema: {
    type: "object",
    properties: {
      title:    { type: "string", description: "Event title." },
      startsAt: { type: "string", format: "date-time", description: "Start, ISO 8601 UTC." },
    },
    required: ["title"],
  },
};

switch (method) {
  case "resources/read":                                          
    return ok(id, { contents: [{ uri: "calendar://week",
      mimeType: "application/json", text: JSON.stringify(EVENTS) }],
      ttlMs: 60000, cacheScope: "private" });

  case "prompts/get":                                             
    return ok(id, { description: PROMPT.description, messages: [{ role: "user",
      content: { type: "text", text: `Read calendar://week and draft a plan. ` +
        `Focus: ${params.arguments?.focus ?? "balance"}.` } }] });

  case "tools/list":                                              
    return ok(id, { tools: [TOOL], ttlMs: 300000, cacheScope: "public" });
}

Εκτελέστε τον και ρωτήστε τον και με τους τρεις τρόπους. Πραγματική έξοδος, ένα μήνυμα ανά γραμμή στο wire, τυλιγμένη εδώ για τη σελίδα, με το request _meta και το identity block του server να έχουν παραλειφθεί:

→ resources/read  {"uri":"calendar://week"}
← {"resultType":"complete","contents":[{"uri":"calendar://week",
   "mimeType":"application/json","text":"[{\"id\":\"e1\",\"title\":\"Standup\",
   \"startsAt\":\"2026-09-07T09:00:00Z\"},{\"id\":\"e2\",\"title\":\"Design review\",
   \"startsAt\":\"2026-09-09T15:00:00Z\"}]"}],"ttlMs":60000,"cacheScope":"private"}

→ prompts/get    {"name":"prepare_week","arguments":{"focus":"deep work"}}
← {"resultType":"complete","description":"Read the week and draft a plan.",
   "messages":[{"role":"user","content":{"type":"text",
   "text":"Read calendar://week and draft a plan. Focus: deep work."}}]}

→ tools/call     {"name":"create_event","arguments":{"title":"Dentist",
                  "startsAt":"2026-09-10T08:30:00Z"}}
← {"resultType":"complete","content":[{"type":"text",
   "text":"Created e3: Dentist at 2026-09-10T08:30:00Z"}],
   "structuredContent":{"id":"e3","title":"Dentist","startsAt":"2026-09-10T08:30:00Z"},
   "isError":false}

Τρεις μέθοδοι, τρία shapes, ένα ημερολόγιο. Τώρα το νόημα:

Σχεδόν όλοι κάνουν και τα τρία tools. Το αποτέλεσμα είναι ένας κατάλογος όπου ένα read που η εφαρμογή θα έπρεπε να είχε προσαρτήσει σιωπηλά ανταγωνίζεται για το attention του μοντέλου με ένα write που χρειάζεται approval, και όπου το ένα πράγμα για το οποίο ο άνθρωπος ήθελε κουμπί είναι θαμμένο σε ένα schema. Δεν κοστίζει τίποτα να το κάνετε σωστά, και αποφασίζεται πριν γράψετε μία γραμμή.

Το calendar tool έχει ένα required argument, title, και ένα optional startsAt. Ζητήστε του να δημιουργήσει event χωρίς ημερομηνία, και επιστρέφει κάτι ενδιαφέρον:

→ tools/call {"name":"create_event","arguments":{"title":"Dentist"}}

← {"resultType":"input_required",
   "inputRequests":{"when":{"method":"elicitation/create","params":{"mode":"form",
     "message":"When should \"Dentist\" start?",
     "requestedSchema":{"type":"object",
       "properties":{"startsAt":{"type":"string","format":"date-time"}},
       "required":["startsAt"]}}}},
   "requestState":"eyJ0aXRsZSI6IkRlbnRpc3QifQ=="}

Ο server δεν έστειλε request. Απάντησε σε εκείνο που του δόθηκε, με resultType: "input_required" και περιγραφή του τι χρειάζεται ακόμη. Ο client συλλέγει την απάντηση από τον άνθρωπο και στη συνέχεια ξαναστέλνει το αρχικό call — με νέο id, μεταφέροντας inputResponses και echo το opaque requestState πίσω:

→ tools/call {"name":"create_event","arguments":{"title":"Dentist"},
   "inputResponses":{"when":{"action":"accept",
     "content":{"startsAt":"2026-09-10T08:30:00Z"}}},
   "requestState":"eyJ0aXRsZSI6IkRlbnRpc3QifQ=="}

← {"resultType":"complete","content":[{"type":"text",
   "text":"Created e3: Dentist at 2026-09-10T08:30:00Z"}],"isError":false}

Αυτό είναι το Multi Round-Trip Requests, που εισήχθη στην τρέχουσα αναθεώρηση, και αντικατέστησε τον παλαιότερο σχεδιασμό όπου οι servers έστελναν JSON-RPC requests πίσω στους clients. Η προδιαγραφή transport δηλώνει πλέον τον κανόνα απερίφραστα: «οι servers δεν ξεκινούν JSON-RPC requests και οι clients δεν στέλνουν JSON-RPC responses».⁴ Υπάρχει μία κατεύθυνση πρωτοβουλίας, και ανήκει στον host.

Δύο client-side features στηρίζονται σε αυτόν τον μηχανισμό, και ένα από αυτά έχει όνομα που θα σας μπερδέψει.

Elicitation είναι ο server που ζητά κάτι από τον άνθρωπο: μια φόρμα με σκόπιμα περιορισμένο JSON Schema — flat objects, primitive properties, χωρίς nesting — ώστε οποιοσδήποτε client να μπορεί να την αποδώσει χωρίς layout engine. Μεταφέρει σκληρό κανόνα: οι servers must not χρησιμοποιούν form mode για να ζητούν «passwords, API keys, access tokens, or payment credentials», και must χρησιμοποιούν URL mode για αυτά, που στέλνει τον χρήστη σε σελίδα την οποία ο client δεν διαβάζει ποτέ.⁷

Sampling είναι ο server που ζητά από το μοντέλο του host ένα generation, ώστε ένας server να μπορεί να είναι ευφυής χωρίς να κρατά API key. Και εδώ είναι η προειδοποίηση λεξιλογίου, επειδή αυτή η λέξη ήδη σημαίνει κάτι άλλο σε αυτό το μάθημα: αυτό δεν είναι το sampling του Κεφαλαίου 17. Τίποτα εδώ δεν αφορά temperature, top-p ή το shape μιας probability distribution. Είναι ένα nested model call που ταξιδεύει προς τα πίσω μέσα από ένα πρωτόκολλο.

Υπάρχει και δεύτερος λόγος να μην το πιάσετε εύκολα: από αυτή την αναθεώρηση, το sampling είναι deprecated, μαζί με roots και logging, υπό το SEP-2577, με μια ωμή προτεινόμενη migration — «ενσωματωθείτε απευθείας με LLM provider APIs αντί για Sampling».⁸ Η ιδέα δεν απέτυχε τεχνικά· απέτυχε να δικαιολογήσει το surface area της, και ένα πρωτόκολλο που μπορεί να αφαιρεί πράγματα είναι πιο υγιές από ένα που δεν μπορεί.

Το statelessness ακούγεται σαν λεπτομέρεια wire format μέχρι να το δοκιμάσετε. Πάρτε την παραπάνω ανταλλαγή τριών μηνυμάτων και εκτελέστε κάθε μήνυμα σε ξεχωριστό process — ένα φρέσκο node calendar.mjs, χωρίς shared memory, χωρίς να μεταφέρεται τίποτα:

process A   tools/call (no date)   → resultType: input_required
                                     requestState: eyJ0aXRsZSI6IkRlbnRpc3QifQ==
process B   tools/call (with the answer, same requestState)
                                   → resultType: complete
                                     "Created e3: Dentist at 2026-09-10T08:30:00Z"
process C   resources/read calendar://week
                                   → events: 2  (Standup, Design review)

Το Process B, που δεν είδε ποτέ την ερώτηση, ολοκλήρωσε ένα multi-round-trip call που ξεκίνησε το process A. Αυτό είναι το νόημα του requestState: το continuation ταξιδεύει στο μήνυμα, άρα τίποτα δεν εξαρτάται από το αν το process είναι το ίδιο.

Το Process C είναι η αποτυχία. Το event δημιουργήθηκε και δεν είναι εκεί — επειδή ο toy server κρατά το EVENTS σε module-level array, και ένα module-level array είναι connection state. Το note της προδιαγραφής ονομάζει το λάθος με ακρίβεια:

μια ανοιχτή connection, όπως ένα STDIO process, δεν είναι conversation ούτε session: οι clients μπορούν να interleave άσχετα requests στο ίδιο transport, και ένας server δεν πρέπει να αντιμετωπίζει την connection ή την process identity ως proxy για conversation ή session continuity.²

Η προδιαγεγραμμένη λύση δεν είναι session. Είναι ένα ρητό handle: ένα creation tool επιστρέφει opaque identifier, και κάθε μεταγενέστερο call το παίρνει ως συνηθισμένο argument. Το πρωτόκολλο δεν έχει καμία έννοια γι’ αυτό — «από τη σκοπιά του wire, ένα handle είναι ένα συνηθισμένο string σε tool result και ένα συνηθισμένο argument σε επόμενα tool calls».⁹ Αυτό βάζει το μοντέλο υπεύθυνο να το μεταφέρει, και τον server υπεύθυνο να επικυρώνει ότι αυτός ο caller επιτρέπεται να το χρησιμοποιεί σε κάθε μεμονωμένο call, επειδή ένα handle είναι όνομα και όχι άδεια.

Κάθε tool που εκθέτει ένας server είναι ένα schema που μπαίνει στο prompt σας σε κάθε request, και το Κεφάλαιο 24 μέτρησε τι κάνει αυτό σε ένα window. Το MCP προσθέτει ένα δεύτερο line item που είναι εύκολο να χαθεί, οπότε αξίζει να μετρηθούν και τα δύο στον reference server παραπάνω.

13 tool definitions (name + description + inputSchema):  1,307 tokens
  cheapest tool, get-tiny-image                              52
  costliest tool, gzip-file-as-resource                     235
server `instructions`, returned by discovery:               312 tokens
                                                          ------
one server, connected, before it is used:                 1,619 tokens

Δύο παρατηρήσεις. Η πρώτη είναι αριθμητική: συνδέστε πέντε servers αυτού του μεγέθους και περίπου οκτώ χιλιάδες tokens του window σας είναι δεσμευμένα σε κάθε turn, για πάντα, είτε το μοντέλο χρησιμοποιεί κάποιο από αυτά είτε όχι — αυτός είναι ο μηχανισμός πίσω από τη μείωση από 150.000 σε 2.000 που παρέθεσε το Κεφάλαιο 24, και ο λόγος που υπάρχει just-in-time tool discovery.

Η δεύτερη είναι security note ντυμένο σαν λογιστική. Το instructions είναι natural-language text, γραμμένο από τον server author, που προσγειώνεται στο prompt του host, και οι tool descriptions δίπλα του είναι το ίδιο. Η προδιαγραφή λέει τι πρέπει να κάνετε γι’ αυτό στις δικές της security principles: τα tool annotations και descriptions «should be considered untrusted, unless obtained from a trusted server», και οι hosts «must obtain explicit user consent before invoking any tool».¹ Το να συνδέετε έναν MCP server δεν είναι προσθήκη dependency. Είναι να παραχωρείτε σε έναν ξένο 1.619 tokens του system prompt σας και το δικαίωμα να καλείται. Το Κεφάλαιο 30 είναι αυτό που συμβαίνει όταν εκείνος ο ξένος είναι hostile.

Όλα σε αυτή την ενότητα ισχύουν για την protocol revision 2026-07-28, την τρέχουσα, όπως διαβάστηκε στις 7 Σεπτεμβρίου 2026. Οι αναθεωρήσεις χρονολογούνται YYYY-MM-DD και η ημερομηνία είναι η τελευταία φορά που έγινε backwards-incompatible change.¹⁰ Το normative document είναι ένα TypeScript file, schema/2026-07-28/schema.ts· το JSON Schema δίπλα του παράγεται από αυτό, γι’ αυτό η προδιαγραφή διαβάζεται εδώ σε TypeScript και γι’ αυτό το να διδάσκετε MCP από οτιδήποτε άλλο είναι να διδάσκετε μετάφραση.

Η governance αλλαγή κάτω από αυτόν τον πίνακα έχει μεγαλύτερη σημασία από οποιαδήποτε μεμονωμένη σειρά. Αυτή η αναθεώρηση υιοθέτησε feature lifecycle and deprecation policy: τα features είναι Active, Deprecated ή Removed, ένα deprecated feature τεκμηριώνει το migration path του και μένει στην προδιαγραφή για τουλάχιστον δώδεκα μήνες πριν γίνει eligible for removal, και υπάρχει registry που παραθέτει όλα όσα βρίσκονται αυτή τη στιγμή σε Deprecated state.⁸ Πριν από αυτή την policy, «deprecated» σε AI protocol σήμαινε ό,τι έλεγε το τελευταίο blog post. Τώρα σημαίνει ημερομηνία.

Αυτό είναι το λεξιλόγιο ολόκληρου του block σε ένα σημείο.

Δύο από αυτά αξίζουν μία πρόταση το καθένα, επειδή εκεί βρίσκεται πραγματικά η σύγχυση.

MCP σε σχέση με A2A δεν είναι αντιπαλότητα, και οι δύο προδιαγραφές το λένε. Το A2A documentation τραβά τη γραμμή με βάση το τι βρίσκεται στο άλλο άκρο: το MCP «defines how an AI agent interacts with and utilizes individual tools and resources, such as a database or an API», όπου ένα tool εκτελεί «specific, often stateless, functions»· το A2A αφορά agents, «more autonomous systems» που «reason, plan, use multiple tools, maintain state over longer interactions, and engage in complex, often multi-turn dialogues». Η δική του σύνοψη είναι η πρόταση που πρέπει να θυμάστε: «A2A is about agents partnering on tasks, while MCP is more about agents using capabilities.»¹¹ Τα δύο φωλιάζουν — μια εφαρμογή χρησιμοποιεί A2A για να φτάσει άλλους agents, και κάθε agent χρησιμοποιεί MCP για να φτάσει τα δικά του tools. Το Κεφάλαιο 25 τράβηξε αυτή τη γραμμή μέσα σε ένα process, ανάμεσα στο να ρωτάς έναν sub-agent και στο να του παραδίδεις τη συζήτηση· το A2A την τραβά ανάμεσα σε οργανισμούς.

MCP σε σχέση με ACP είναι σύγκριση με stale premise, και ακριβώς γι’ αυτό αξίζει να απαντηθεί. Το Agent Communication Protocol ήταν ξεχωριστό open standard για agent-to-agent messaging. Το δικό του documentation ανοίγει πλέον με την ειδοποίηση: «ACP is now part of A2A under the Linux Foundation!»¹² Η ειλικρινής απάντηση στο «MCP ή ACP;» τον Σεπτέμβριο του 2026 είναι ότι η ερώτηση έχει μία επιλογή λιγότερη από όσες υπονοούν οι σελίδες που κατατάσσονται γι’ αυτή.

Και η σύγκριση που ζητούν περισσότερο, mcp vs api, έχει τη λιγότερο ενδιαφέρουσα απάντηση: το MCP είναι API. Αυτό που προσθέτει δεν είναι δύναμη, είναι conventions — ένα fixed set από method names, ένα discovery call, μια control hierarchy πάνω στα primitives και ένα isolation model. Παραιτείστε από την ελευθερία να σχεδιάσετε το δικό σας interface και παίρνετε κάθε host που μιλά το πρωτόκολλο, που είναι το trade που έχει προσφέρει κάθε πρωτόκολλο στην ιστορία.

Μπορείτε πλέον να διαβάσετε την προδιαγραφή χωρίς μεταφραστή, να ξεχωρίσετε ένα resource από ένα tool από ένα prompt με βάση το ποιος το ελέγχει, να πληκτρολογήσετε request με το χέρι όταν ένα client library σας λέει ψέματα, και να χρονολογήσετε οποιοδήποτε άρθρο για MCP διαβάζετε με βάση το ποια από τα deprecated features εξακολουθεί να διδάσκει ως τρέχοντα.

Αυτό που δεν έχετε κάνει είναι να στείλετε ένα. Το Κεφάλαιο 27 γράφει τον ίδιο server δύο φορές — TypeScript και Python, δίπλα δίπλα, επειδή το MCP είναι η μία πραγματικά δίγλωσση περιοχή αυτού του μαθήματος και οι αριθμοί το λένε και προς τις δύο κατευθύνσεις. Καλύπτει σωστά τα δύο live transports, τον inspector, packaging, και το μισό του πρωτοκόλλου που αυτό το κεφάλαιο άφησε επίτηδες απέξω: authorization. Επειδή τη στιγμή που ο server σας είναι remote αντί για subprocess στο δικό σας laptop, ο client ενός ξένου θα παρουσιάσει ένα token, και ο κανόνας της προδιαγραφής για το τι επιτρέπεται να κάνετε με αυτό είναι ασυνήθιστα αυστηρός.

Πράγμα που εγείρει το ερώτημα που πρέπει να απαντήσει το επόμενο κεφάλαιο, και δεν είναι φιλικό: αν ένα token φτάσει στον server σας και εκδόθηκε για το audience κάποιου άλλου, τι ακριβώς σας εμποδίζει να το προωθήσετε;

Κάθε quotation, method name, error code και κανόνας σε αυτό το κεφάλαιο διαβάστηκε από την προδιαγραφή Model Context Protocol, revision 2026-07-28, στις 7 Σεπτεμβρίου 2026. Κάθε trace παρήχθη τοπικά σε Node 22: ο toy calendar server είναι 101 γραμμές χωρίς dependencies, και ο reference server είναι το δημοσιευμένο npm package που ονομάζεται παρακάτω. Δεν κλήθηκε paid API για να γραφτεί αυτό το κεφάλαιο — τίποτα εδώ δεν χρειάζεται μοντέλο, που είναι και το ίδιο το point.

Οι μετρήσεις: @modelcontextprotocol/server-everything@2026.8.31, δημοσιευμένο στις 31 Αυγούστου 2026, χτισμένο πάνω στο @modelcontextprotocol/sdk@1.30.0, δημοσιευμένο στις 27 Ιουλίου 2026 — μία ημέρα πριν από την αναθεώρηση που περιγράφει αυτό το κεφάλαιο. Απαντά στο server/discover με -32601, negotiates 2025-11-25 όταν του ζητείται 2026-07-28, και σερβίρει tools/list χωρίς κανένα handshake. Ο κατάλογός του είναι 13 tools σε 7.663 bytes· τα token counts είναι o200k_base μέσω tiktoken, πάνω στα name, description και inputSchema κάθε definition, που είναι αυτό που ένας provider αποδίδει στο prompt σας και όχι όσο ζυγίζει το JSON-RPC frame.

Anthropic, Code execution with MCP: building more efficient agents, 4 Νοεμβρίου 2025, είναι η πηγή του αριθμού 150.000-to-2.000, που παρατέθηκε και χρησιμοποιήθηκε στο Κεφάλαιο 24 και εδώ απλώς αναφέρεται.