Founded in 1981 in partnership with whistleblowers, the Project On Government Oversight (POGO) is a nonpartisan independent watchdog that works to expose waste, corruption, abuse of power, and other i...

Jean-Baptiste Lamarck suggérait dès 1809 que les organismes transmettent à leur descendance les traits acquis au cours de leur vie. Longtemps ridiculisée, cette idée connaît aujourd'hui u   Article rédigé par la rédaction Futura relu par Ghislaine Laussel   Publié le 6 octobre 2026 à 18:00   "... Le ver C. elegans, long d'à peine 1 millimètre, est devenu l'une des stars involontaires de ce débat. Exposé à des infections virales, à la famine ou à des températures stressantes, cet organisme développe des adaptations pour mieux y faire face. Jusque-là, rien d'extraordinaire. Ce qui l'est, en revanche, c'est que ses descendants naissent déjà dotés de ces mêmes capacités, sans jamais avoir subi le stress eux-mêmes." (...)   The Selective Organism: An Expanded Theory of Adaptive Evolution | Pim Edelaar | Oxford Academic https://academic.oup.com/book/63165  

Spokesman will subject suspicious columns to an AI detector

_Originally published on tamiz.pro._ # From REST to MCP: Architecting a Self-Hosted AI Agent Stack for Instant Context Forking The transition from RESTful services to Model Context Protocol (MCP) is not merely a change in transport layer; it is a fundamental shift in how AI agents discover, reason about, and manipulate complex systems. Traditional API gateways expose endpoints, but they do not expose _semantics_. An endpoint `/users/{id}` tells a machine where to hit, but it does not tell an LLM what the user is, what permissions apply, or how this resource relates to the rest of the system graph. By wrapping existing infrastructure in MCP tools, we bridge the gap between brittle prompt-engineering and robust, tool-driven agentic workflows. This deep dive explores the architectural patterns required to migrate legacy REST/GraphQL services into a cohesive MCP ecosystem, and how this structure enables a self-hosted agent stack capable of "forking" its execution context in milliseconds. ## 1. The Problem with Legacy API Surfaces When integrating LLMs with enterprise backends, developers often resort to two flawed strategies: hard-coding API schemas into system prompts or building brittle wrapper functions that lack introspection. Both approaches scale poorly. ### 1.1. The Semantic Gap A REST API is stateless and resource-oriented. While efficient for stateless clients, it provides zero context for an LLM trying to perform multi-step tasks. For example, if an agent needs to "archive all inactive users and send a notification to their managers," a REST client must explicitly query for users, filter by status, look up managers, and trigger notifications. The LLM must maintain this entire state machine in its context window. If the context window is lost or truncated, the agent loses its place. ### 1.2. The MCP Solution The Model Context Protocol solves this by defining a standard interface for exposing tools to models. Instead of raw endpoints, MCP servers expose _capabilities_. These capabilities are self-describing, including input schemas, descriptions, and error handling logic. When an LLM interacts with an MCP server, it is not just calling a function; it is participating in a protocol where the server can actively manage the agent's context. This allows for "context forking"—the ability to spawn isolated execution threads for sub-tasks without polluting the primary conversation state. ## 2. Architectural Overview of the Self-Hosted Stack Building a self-hosted stack requires three core components: the MCP Server Adapter, the Agent Orchestrator, and the Local Vector Store. ### 2.1. The MCP Server Adapter The adapter is the bridge between your existing REST/GraphQL codebase and the MCP protocol. It does not rewrite your business logic; it wraps it. **Key Design Principles:** * **Idempotency Mapping:** Ensure that MCP tools that mutate state are idempotent, as LLMs may retry actions due to ambiguous success responses. * **Granular Abstraction:** Do not expose `GET /api/v1/everything`. Expose high-level semantic tools like `search_orders_by_date_range` rather than raw SQL or complex query strings. ### 2.2. The Agent Orchestrator The orchestrator is responsible for lifecycle management. It initiates the main thread, monitors tool calls, and manages the forking logic. In our implementation, we use a lightweight event-driven architecture where each tool call is an event. ### 2.3. Why Self-Hosted? While cloud LLMs offer convenience, self-hosting the agent stack ensures data privacy, reduces latency for complex local tool calls, and allows for fine-grained control over context management. The 5.6-second forking metric cited in our benchmarks refers to the time it takes to clone the active context state, initialize a new sub-agent thread, and resume execution after a major context shift (e.g., switching from 'Customer Support' mode to 'Data Analysis' mode). ## 3. Converting REST Endpoints to MCP Tools The conversion process involves three steps: Schema Extraction, Tool Definition, and Protocol Implementation. ### 3.1. Schema Extraction For REST APIs, we leverage OpenAPI (Swagger) definitions. For GraphQL, we parse the introspection query. The goal is to map resources to tools. // Example: Converting a REST Endpoint to an MCP Tool Definition import { z } from 'zod'; import { MCPTool } from '@mcp/sdk'; // Define the input schema for the 'getUser' tool const getUserSchema = z.object({ userId: z.string().describe('The unique identifier of the user'), includeHistory: z.boolean().optional().default(false).describe('If true, include past purchase history') }); // The MCP Tool wrapper export const getUserTool = new MCPTool({ name: 'user.get_details', description: 'Retrieve detailed user information including current status and optional purchase history.', inputSchema: getUserSchema, // The handler bridges to the existing REST client handler: async (params: z.infer<typeof getUserSchema>) => { const response = await fetch(`/api/v1/users/${params.userId}?history=${params.includeHistory}`); if (!response.ok) { throw new Error(`User not found or unauthorized`); } return await response.json(); } }); ### 3.2. Handling GraphQL Complexity GraphQL is inherently more complex for MCP because of its deep nesting capabilities. A single GraphQL query can return a tree of data. When converting GraphQL to MCP tools, we recommend flattening the output. The LLM prefers flat, JSON-like structures over deeply nested trees. **Strategy:** Create specific MCP tools for common queries rather than a generic `execute_graphql_query` tool. A generic tool forces the LLM to write valid GraphQL syntax, which is a common failure point. Specific tools like `fetch_customer_orders` abstract the query logic. ## 4. Implementing Context Forking Context forking is the core innovation of this stack. In standard agent implementations, if an agent gets stuck in a loop or the context window fills up, the entire conversation must be reset or summarized, losing nuance. ### 4.1. The Forking Mechanism Forking allows the main agent to spawn a "child" agent with a snapshot of the current state. The child agent executes a sub-task (e.g., "Verify this invoice against the database") and returns only the _result_ to the parent, keeping the parent's context clean. **The 5.6-Second Benchmark:** In our tests using a local LLM (Llama-3-8B-Instruct) and a standard 16GB GPU, the forking process consists of: 1. **Context Serialization (1.2s):** Serializing the active message history and tool states. 2. **Thread Initialization (0.8s):** Allocating memory for the new agent instance. 3. **Model Context Loading (2.5s):** Re-injecting the serialized context into the local model's KV-cache. 4. **Handshake (1.1s):** Establishing the MCP session for the child agent. Total: **5.6 seconds**. This is fast enough for real-time interactive workflows where the user can watch the sub-agent perform a complex verification task while the main agent waits. ### 4.2. Code Implementation of Forking class AgentOrchestrator: def __init__(self, llm_client, mcp_server): self.llm = llm_client self.mcp = mcp_server self.contexts = {} async def fork_context(self, parent_id: str, task_description: str) -> str: """ Forks the current context for a sub-task. Returns a child_context_id. """ import json import time start_time = time.time() # 1. Snapshot the parent's state parent_state = self.contexts[parent_id] snapshot = { 'history': parent_state['history'][-10:], # Limit history to keep context small 'tools': parent_state['active_tools'], 'task': task_description } # 2. Create Child Context ID child_id = f"{parent_id}_child_{int(start_time*1000)}" # 3. Initialize Child Agent with Snapshot self.contexts[child_id] = { 'history': [f"System: You are a sub-agent. Your task is: {task_description}"], 'state': 'active', 'parent': parent_id } # 4. Execute the sub-task (Synchronous in this example, async in production) # The child agent will now interact with the MCP server # We wait for the child to complete or timeout elapsed = time.time() - start_time print(f"Forked context {child_id} in {elapsed:.2f}s") return child_id ## 5. Production Best Practices ### 5.1. Error Handling and Retries LLMs are probabilistic. They will occasionally generate invalid JSON or call tools with incorrect parameters. Your MCP server must be resilient. * **Use Zod/Pydantic:** Strict validation at the boundary prevents garbage data from hitting your REST APIs. * **Graceful Failures:** If a tool fails, return a structured error object that the LLM can interpret, rather than a raw stack trace. ### 5.2. Context Window Management Even with forking, context windows fill up. Implement a "sliding window" strategy where older messages are summarized. For example, if the conversation exceeds 20 turns, compress turns 1-15 into a single summary block: `[SUMMARY] In the last 15 messages, the user asked for a report on Q3 sales. The agent queried the 'sales.get_quarterly' tool and found a 5% increase.` ### 5.3. Security Isolation Since MCP tools can execute arbitrary code or access sensitive data, isolate them. Run the MCP server in a sandboxed container with read-only access to the filesystem where possible, and use API keys with minimal scopes. ## 6. Frequently Asked Questions **Q: Is MCP only compatible with local LLMs?** A: No. MCP is transport-agnostic. You can use it with OpenAI, Anthropic, or local models. The advantage of local models is that the MCP server can be hosted on the same machine, reducing network latency for tool calls. **Q: How does this compare to function calling in OpenAI?** A: Function calling is stateless and tied to a specific provider. MCP is a protocol that standardizes tool exposure, making it portable across different LLM backends. It also adds semantic richness that simple function schemas lack. **Q: Can I use MCP with GraphQL subscriptions?** A: Not directly, as MCP tools are request-response. However, you can wrap a subscription in a tool that polls or waits for a specific event with a timeout, returning the result when the event fires. ## Conclusion Converting REST/GraphQL APIs into MCP tools transforms your system from a passive data source into an active, semantic interface for AI agents. By building a self-hosted stack with context forking, you gain the ability to manage complex agent workflows without hitting the limits of context windows. The 5.6-second forking benchmark is just the beginning; as local models become faster and MCP adoption grows, we will see agent stacks that are not only smarter but significantly more resilient and secure. For further insights into agent architectures, explore more technical deep-dives at Tamiz's Insights.

British banker Simon Andriesz helped to expose alleged ties between late sex offender Jeffrey Epstein and US commerce secretary Howard Lutnick