The MCP server: your workspace, from your own tools

Your company's documents, memory and data tables live in the Agentique workspace. You live in a terminal, an editor, or an agent you are building yourself. The MCP server connects the two: one HTTP endpoint that exposes the workspace's tools to any client speaking the Model Context Protocol.

MCP is an open standard, and Agentique implements it as a plain JSON-RPC 2.0 endpoint over the Streamable HTTP transport. There is no SDK to install and no client we favour: a desktop AI app, an IDE plugin, a cron script, an internal service, anything that can send an HTTP POST with one header can use the workspace. The server speaks protocol versions 2024-11-05 through 2025-06-18, so both older and current clients negotiate cleanly.

What the endpoint exposes

Thirty-one tools, curated on purpose. Search and retrieval (intelligent_search, keyword_search, list_documents, get_document), workspace memory (search_memory, save_memory), data tables read-only (list_entity_types, search_entity_records), web access read-only (web_search, fetch_webpage), pure calculation (calculate, convert_units), Google Sheets and Drive when your workspace has Google connected, SPV e-Factura status and sync (spv_status, spv_trigger_sync), public tenders (seap_search, seap_market, tender_list, tender_show, tender_analyze, tender_decide, company_file, tender_dossier, tender_dossier_build), and findings-report generation (create_findings_report).

Just as deliberate is what is missing. Nothing destructive is reachable with an API key: no deleting, no sending email, no arbitrary outbound requests (the web tools are search and read-only fetch). Actions like those stay in the workspace UI, where a human confirms each one. A leaked key must never be able to email your clients or empty a folder, so the surface is built as if every key will leak one day.

That is the default posture, not a hard ceiling. If your integration genuinely needs one of the excluded actions, tell us: we would rather extend the surface deliberately, with the same guardrails, than ship dangerous defaults to everyone.

Connect in two steps

Everything you need sits in Settings, in the MCP server panel: the exact endpoint URL of your workspace, and your API keys. A workspace admin creates a key with a name and scopes, and the plaintext (an ak_ token) is shown exactly once, at creation. Only a hash is stored, so copy it then. Keys can be revoked at any moment, can carry an expiry date, and show when they were last used.

First, prove the connection with curl:

curl -s https://your-workspace-endpoint/api/v1/mcp/ \
  -H "Content-Type: application/json" \
  -H "X-API-Key: ak_your_key" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

You get back all thirty-one tools with their JSON schemas. A plain GET on the same URL returns server info, which makes health checks trivial.

Then point your client at it. Clients that speak Streamable HTTP take a config in this shape. Claude Code reads it from .mcp.json at the project root, and Cursor takes the same url plus headers pair in .cursor/mcp.json:

{
  "mcpServers": {
    "agentique": {
      "type": "http",
      "url": "https://your-workspace-endpoint/api/v1/mcp/",
      "headers": { "X-API-Key": "ak_your_key" }
    }
  }
}

Some clients only speak stdio. For those there is a bridge: a single-file Python script, standard library only, Python 3.10+, downloadable from the same Settings panel. It reads JSON-RPC from stdin and forwards it to your endpoint over HTTPS. Claude Desktop is the usual example:

{
  "mcpServers": {
    "agentique": {
      "command": "python3",
      "args": ["/absolute/path/to/agentique-mcp-bridge.py"],
      "env": {
        "AGENTIQUE_URL": "https://your-workspace-endpoint/api/v1/mcp/",
        "AGENTIQUE_API_KEY": "ak_your_key"
      }
    }
  }
}

Scopes and limits, in the open

Every key belongs to one workspace and can only ever see that workspace's data. Scopes keep a key as narrow as its job: read covers search, documents, memory reads, table queries and tender lookups; write adds memory saves, Sheets/Drive writes, the SPV sync trigger and three tender tools (tender_analyze, tender_decide, tender_dossier_build); the calculation tools need no scope at all; admin unlocks everything and is rarely what you want. tender_decide records a decision only when the user states it, never on its own. Rate limits are 60 requests per minute per key, and 15 per minute for the expensive tools (semantic search, the web tools, Drive import, report generation). Responses are synchronous JSON, no SSE: a request returns when the tool returns.

Three things worth building

Ask the workspace without leaving the editor. "What payment terms did we agree with this supplier?" answered inside the IDE, source document and page in the response, while you write the code that depends on the answer. The same answers the workspace gives, in the tools where you already are; how the answering works is documented here.

A reconciliation script. A nightly job pulls records from a data table, compares them with your internal system, and writes the differences into a Google Sheet the team already watches. Read scope for the query, write scope for the sheet, twenty lines of code.

Your own agent, with real context. Building an agent in any framework that supports MCP? One config block hands it your company's documents and memory as tools, with every guardrail above already enforced server-side, not promised client-side.