Questa è parte 2 di "LLM come componenti". Parte 1: Perché i LLM falliscono come sensori copre l'errore di categoria dell'uso dei LLM per la percezione. Questo articolo copre il errore di category dell'utilizzo del MCP come architettura.

"Come faccio a costruire un server MCPM SK1 è la domanda sbagliata.

Esistono SDK. Un LLM può costruirne uno in pochi secondiM SK1 La vera domanda è:

Quale ruolo dovrebbe avere un server MCP all'interno di un sistema che non deve esserci?

La scarsa abilità ora consiste nel progettare Il sistema circostante MCP: autorità, autorizzazioneM SK2 verificabilitàMSL3 e controllo deterministicoM SL4 Il MCP si occupa del trasporto MLS5 queste preoccupazioni vivono altroveMsl6

Questo articolo spiega come uso MCP. senza agenti, autonomia, o vibrazioni, e perché la maggior parte degli esempi MCP riproducono gli stessi problemi che abbiamo visto con l'uso di strumenti senza restrizioni.

Che cos'è in realtà il MCP (E non è'tM SK2

MCP (Model Context Protocol protocollo di fili. Si muove:

• Input e output
• Schema
• Metadati degli strumenti
• Ricerca di capacità

Lo fa. Non.:

• Decidere Quando? Gli strumenti dovrebbero funzionare.
• Validare la verità
• Fornire fiducia
• Gestire gli effetti collaterali

flowchart LR
    subgraph MCP["MCP: What It Does"]
        Schema[Schema Discovery] --> Transport[Transport Layer]
        Transport --> Invoke[Tool Invocation]
        Invoke --> Response[Structured Response]
    end

    subgraph NotMCP["Not MCP's Job"]
        When[When to run?]
        Trust[Is this true?]
        Should[Should we act?]
        Safe[Is this safe?]
    end

    style MCP fill:none,stroke:#16a34a,stroke-width:2px
    style NotMCP fill:none,stroke:#dc2626,stroke-width:2px
    style Schema fill:none,stroke:#059669,stroke-width:2px
    style Transport fill:none,stroke:#059669,stroke-width:2px
    style Invoke fill:none,stroke:#059669,stroke-width:2px
    style Response fill:none,stroke:#059669,stroke-width:2px
    style When fill:none,stroke:#dc2626,stroke-width:2px
    style Trust fill:none,stroke:#dc2626,stroke-width:2px
    style Should fill:none,stroke:#dc2626,stroke-width:2px
    style Safe fill:none,stroke:#dc2626,stroke-width:2px

MCP è più vicino a OpenAPI di quanto non sia ad un sistema di agenti.

Se' usate MCP come strata di ragionamento, avete già fatto lo stesso errore nella categoria descritta in Parte 1.

Se MCP è il trasporto, allora l'architettura vive sopra di esso: orchestrazioneMSC2 politicaM SK3 validazioneMST4 persistenzaMSM5 Il resto di questo articolo è quella strataMSV6

Il principio principale: Proposition vs Decide

Questa è la regola fondamentale. RAG ridotto e Fuzzinesse limitata:

• Componenti probabilistice propose
• I sistemi deterministici decidono.

Nei miei sistemi:

• I LLM sono mai. le autorità
• Gli strumenti sono: mai. autonomo.
• Ogni risposta del MCP è una Suggestione, non è un fatto

"DeterministaM SK1 qui non significa 'non significa semplicistica. Significa regola-governed,reproducibileM SK2 e verificabile.

flowchart TD
    subgraph Proposers["Proposers (Probabilistic)"]
        LLM[LLM Synthesis]
        MCP1[MCP Tool Response]
        MCP2[MCP Tool Response]
    end

    subgraph Constrainer["Constrainer (Deterministic)"]
        Validate[Validate Proposals]
        Compare[Compare Confidence]
        Policy[Apply Policy Rules]
        Decide[Accept / Reject / Escalate]
    end

    subgraph Persistence["Persistence (Facts)"]
        Facts[(Verified Facts<br/>With Provenance)]
    end

    LLM --> Validate
    MCP1 --> Validate
    MCP2 --> Validate
    Validate --> Compare
    Compare --> Policy
    Policy --> Decide
    Decide --> Facts

    style Proposers fill:none,stroke:#d97706,stroke-width:2px
    style Constrainer fill:none,stroke:#2563eb,stroke-width:2px
    style Persistence fill:none,stroke:#16a34a,stroke-width:2px
    style LLM fill:none,stroke:#d97706,stroke-width:2px
    style MCP1 fill:none,stroke:#d97706,stroke-width:2px
    style MCP2 fill:none,stroke:#d97706,stroke-width:2px
    style Validate fill:none,stroke:#2563eb,stroke-width:2px
    style Compare fill:none,stroke:#2563eb,stroke-width:2px
    style Policy fill:none,stroke:#2563eb,stroke-width:2px
    style Decide fill:none,stroke:#2563eb,stroke-width:2px
    style Facts fill:none,stroke:#16a34a,stroke-width:3px

Il server MCP non decide.

Perché "Tools" sono il modello mentale sbagliato

La configurazione MCP di default è:

• "Esibire i metodi come strumenti"
• "Lasciamo che il modello scelga quale strumento chiamare"
• "Prendere il permesso prima dell'esecuzione"

Questo fallisce per ragioni prevedibili:

1. Le descrizioni degli strumenti diventano prompt.: Il LLM inferisce l'intenzione dalla formulazione, non dalla semantica del schema.
2. La scelta degli strumenti si muove.: Il modello ottimizza la plausibilità, non la correttezzaM SK2 e sceglie gli strumenti sulla base della similitude della descrizione.
3. I richiami di permesso sono UX, non di sicurezza.: Un dialogo modale non impedisce che sia selezionata l'outil sbagliato.
4. Non si può ripetere.: Non si può riprodurre una sessione perché la scelta degli strumenti era probabilistica.

Reframe: I punti di fine del MCP pubblicano i segnaliM SK1 non le azioni.

• I segnali sono codificati, limitati, e attribuibili.
• Ogni segnale ha una provenienza di fiducia,, e puntatori di prove.
• Il linguaggio naturale è una lingua. Layere di presentazione, non il substrato

flowchart LR
    subgraph Wrong["❌ Tools Mental Model"]
        Desc[Tool Description<br/>'Gets weather for city'] --> LLM1[LLM Chooses]
        LLM1 --> Execute[Execute Action]
        Execute --> Trust1[Trust Result?]
    end

    subgraph Right["✓ Signals Mental Model"]
        Schema2[Typed Schema<br/>city: string, units: enum] --> Invoke2[Deterministic Invoke]
        Invoke2 --> Signal[Signal Response<br/>+ confidence + provenance]
        Signal --> Validate2[Constrainer Validates]
    end

    style Wrong fill:none,stroke:#dc2626,stroke-width:2px
    style Right fill:none,stroke:#16a34a,stroke-width:2px
    style Desc fill:none,stroke:#dc2626,stroke-width:2px
    style LLM1 fill:none,stroke:#dc2626,stroke-width:2px
    style Execute fill:none,stroke:#dc2626,stroke-width:2px
    style Trust1 fill:none,stroke:#dc2626,stroke-width:2px
    style Schema2 fill:none,stroke:#16a34a,stroke-width:2px
    style Invoke2 fill:none,stroke:#16a34a,stroke-width:2px
    style Signal fill:none,stroke:#16a34a,stroke-width:2px
    style Validate2 fill:none,stroke:#16a34a,stroke-width:2px

Signal Contracts Over Chat

Ogni punto di fine MCP nei miei sistemi ha:

• Un schema.: Input e output digitati, non liberoM SK2 testo formale
• Confidenza: Quanto è sicuro questo risultato?
• Provenenza: Da dove viene questo?
• Indicatori di prova: Cosa può essere verificato indipendentementeM SK1

Niente gratis-autorità del testoM SK1 Niente "best effort

Esempi dei sistemi di produzione:

La regola: Se un risultato non può essere validatoM SK1, non è accettato '

Questo è lo stesso principio. Regola di progettazione #5: i fatti hanno bisogno di proveM SK1

Il Constrainer: La parte che tutti passano

La maggior parte dei tutorial MCP mostra:

1. Definire gli strumenti
2. Connettersi a LLM
3. Lascia andare.

Il componente che manca è il Constrainer - la logica deterministica che :

• valuta le proposte competitive
• Esegue la politica.
• Decide cosa rimane e cosa viene rifiutato.
• I percorsi verso l'escalamento quando la fiducia è bassa

flowchart TD
    subgraph Sources["Signal Sources"]
        Heuristics[Heuristics<br/>Text-likeliness: 0.3]
        LocalModel[Local Model<br/>Florence-2 OCR: 0.85]
        LLMCall[LLM Escalation<br/>GPT-4V: 0.92]
    end

    subgraph Constrainer["Constrainer Logic"]
        Receive[Receive All Signals]
        Check{Confidence<br/>≥ 0.7?}
        Cross[Cross-Validate<br/>Signals Agree?]
        Accept[Accept as Fact]
        Reject[Reject / Log]
        Escalate[Escalate to<br/>Higher Tier]
    end

    Heuristics --> Receive
    LocalModel --> Receive
    LLMCall --> Receive

    Receive --> Check
    Check -->|Yes| Cross
    Check -->|No| Escalate
    Cross -->|Yes| Accept
    Cross -->|No| Reject

    style Sources fill:none,stroke:#d97706,stroke-width:2px
    style Constrainer fill:none,stroke:#2563eb,stroke-width:2px
    style Heuristics fill:none,stroke:#d97706,stroke-width:2px
    style LocalModel fill:none,stroke:#d97706,stroke-width:2px
    style LLMCall fill:none,stroke:#d97706,stroke-width:2px
    style Receive fill:none,stroke:#2563eb,stroke-width:2px
    style Check fill:none,stroke:#2563eb,stroke-width:2px
    style Cross fill:none,stroke:#2563eb,stroke-width:2px
    style Accept fill:none,stroke:#16a34a,stroke-width:2px
    style Reject fill:none,stroke:#dc2626,stroke-width:2px
    style Escalate fill:none,stroke:#7c3aed,stroke-width:2px

Decisioni reali di constrainer:

• Recludere la legenda LLM quando l'euristica non è d'accordo sul testo-likeliness
• Preferisce meno-confidenza ma OCR dimostrato rispetto ad altoM SK1confidentità testi allucinati
• Escalare alla visione LLM solo quando la fiducia nel modello locale < 0.7

MCP collega i componenti. Il constrainer li governa.

Togliere il LLM (E perché lo faccio)

I miei server MCP funzionano ancora con il LLM disattivato.

Questo non è un modo degradato. Il modo primario.

Se il vostro sistema smette di funzionare quando il LLM è inaccessibile, l'LLM stava facendo un lavoro non avrebbe dovuto' averlo fatto

Le funzioni di base:

• Sommazione deterministica dai fatti estrattos
• Evidence-prima ricerca tramite inserzioni e filtri
• Queries strutturate contro la base di dati dei fatti

Il LLM diventa:

• Una strata di sintesi (opzionale)
• Un motore di spiegazione (quello richiesto)
• Un ricchiere (per il risultato della lingua naturale)

Il LLM è Non.:

• Un decisionista.
• La memoria
• Un motore della verità.

flowchart TD
    subgraph AlwaysOn["Always On (Deterministic)"]
        Sensors[Sensors + Heuristics]
        Local[Local Models<br/>Florence-2, Whisper, CLIP]
        Facts[(Facts Database)]
        Query[Query Engine]
    end

    subgraph Optional["Optional (LLM)"]
        Synthesis[Natural Language Synthesis]
        Explain[Explanation Generation]
    end

    Sensors --> Local
    Local --> Facts
    Facts --> Query
    Query --> Synthesis
    Query --> Explain

    style AlwaysOn fill:none,stroke:#16a34a,stroke-width:2px
    style Optional fill:none,stroke:#6b7280,stroke-width:2px,stroke-dasharray: 5 5
    style Sensors fill:none,stroke:#16a34a,stroke-width:2px
    style Local fill:none,stroke:#16a34a,stroke-width:2px
    style Facts fill:none,stroke:#16a34a,stroke-width:3px
    style Query fill:none,stroke:#16a34a,stroke-width:2px
    style Synthesis fill:none,stroke:#6b7280,stroke-width:2px
    style Explain fill:none,stroke:#6b7280,stroke-width:2px

Perché questo conta:

MCP come confine, Non un'integrazione

Tratto il MCP come una specie di I confini rigidi.:

• L'isolamento del processo: I server MCP funzionano in processi separati
• Inputs impliciti/outputs: Nessuno stato mutabile condiviso
• Nessun contesto ambientale.: Ogni chiamata viene valutata su input espliciti, non residuo di conversazione
• Contratti tipificati: Le violazioni del schema sono errori, non avvertimenti

Questo contrasta con:

• In-agenti di processo con memoria condivisa
• Prompt-l'accumulo di contesti nascosti
• "Conversazione" uso di strumenti dove i giri precedenti influenzano il comportamento

Perché le frontiere contano:

1. Replay: Riproducere qualsiasi sessione ripetendo le input.
2. Le revisioni: Ogni segnale ha un'origine tracciabile.
3. Test deterministici: Le stesse input → le stesse output
4. La conformità: catene decisionali spiegabili

flowchart LR
    subgraph Process1["Process: Orchestrator"]
        Orch[Orchestrator<br/>Constrainer Logic]
    end

    subgraph Process2["Process: MCP Server 1"]
        MCP1[Image Analysis<br/>Signals]
    end

    subgraph Process3["Process: MCP Server 2"]
        MCP2[Audio Analysis<br/>Signals]
    end

    subgraph Process4["Process: MCP Server 3"]
        MCP3[Video Analysis<br/>Signals]
    end

    Orch <-->|MCP Protocol| MCP1
    Orch <-->|MCP Protocol| MCP2
    Orch <-->|MCP Protocol| MCP3

    style Process1 fill:none,stroke:#2563eb,stroke-width:2px
    style Process2 fill:none,stroke:#16a34a,stroke-width:2px
    style Process3 fill:none,stroke:#16a34a,stroke-width:2px
    style Process4 fill:none,stroke:#16a34a,stroke-width:2px
    style Orch fill:none,stroke:#2563eb,stroke-width:2px
    style MCP1 fill:none,stroke:#16a34a,stroke-width:2px
    style MCP2 fill:none,stroke:#16a34a,stroke-width:2px
    style MCP3 fill:none,stroke:#16a34a,stroke-width:2px

Mode di fallimento Esempi MCP Don't Talk About

Esempi di fallimento reali dall'uso di MCP senza restrizioni:

Il thread comune: Questi fallimenti avvengono perché il LLM è considerato un'autorità affidabile..

La soluzione: Le LLM propongono:,, i constrainer decidono: ,, i fatti persistono..

Cosa fa la MCP bene (Quando viene usata correttamente)

MCP è eccellente per:

• Ricerca di capacità: Enumerazione del tempo di corsa dei segnali disponibili
• Composizione del processo Inter-: Lungare i confini tra i componenti
• Interoperabilità degli strumenti: Funziona con qualsiasi cliente MCP-compatibile
• Modello-integrazione agnostica: Swap LLMs senza cambiare i contratti di segnale

MCP è Non.:

• Un sistema di agenti.
• Un sistema di ragionamento.
• Un strato di sicurezza.
• Un confine di fiducia.

Usare MCP per quello che è: un protocollo di fili per la comunicazione strutturata tra i componenti.

Dove si ferma il MCP

Il MCP standardizza il modo in cui i modelli e gli strumenti scambiano contesto. Non definisce chi è autorizzato a agire, nelle quali condizioniM SK2 o come le decisioni sono controllateMSC3

Esistono altri approcci per formalizzare queste restrizioni ( talvolta descritti come Protocolli di Capacità d'AzioneM SK1 ACP): Autorizzazione , AttestazioneMSC4 Trascende di Riudimento

Questo articolo non riguarda l'ACP, ma il principio di progettazione. Il trasporto e la governance sono preoccupazioni separate..

MCP ti dice. Come? per chiamare uno strumento. qualcos'altro deve decidere. Se Dovreste. Nei miei sistemi, che ' è il constrainerM SK3 Nei sistemi aziendaliMSC4 potrebbe essere un motore di politicaMNK5

Demo MCP vs Production MCP

Conclusione

MCP consente composizione. Il determinismo permette La fiducia.. LLMs attivano Fluenza..

Ma solo se:

La probabilità propone — e il determinismo persisteM SK1

Il MCP senza constrainer è solo un'injezione rapida con ulteriori passi.

Rendere la sintesi l'ultimo passo. Rendere il LLM opzionale. Rende tutti i fatti trascettibiliM SK2

Esempi chiave

• MCP (Model Context Protocol): Protocollo di fili per la scoperta degli strumenti e l'invocation tra processi
• Construitore: Logica deterministica che valuta le proposte e decide cosa rimane.
• Il segnale: Rispondenza digitata con fiduciaM SK1 provenienza, e indicatori di prove
• Propositore: Qualunque componente
• Indicatore di prova: Riferimento alla fonte verificabile (box di confineM SK2 tastiera temporale, inserzioneMSC4

Article connessi

In precedenza nella serie: Parte 1: Perché i LLM falliscono come sensori

• Reduced RAG: Map-Reduce for Probabilistic Systems
• ImageSummarizer: Intelligenza immagine limitata Fuzzy
• VideoSummarizer: RAG ridotto per video
• StyloFlow: Signal-Workflow guidati