# Synap402 [Health: Active]

**Category:** 🗣️ Conversational AI  
**Repository:** https://github.com/weare-linkrra/linkrra-synap  
**GitHub Stars:** 0  
**npm Downloads (last month):** 642  
**Views:** 2  
**Installs:** 1  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/synap402

## Description
Remote MCP server for Synap402, an OpenAI-compatible inference API for open models (Qwen, gpt-oss, Gemma, GLM, DeepSeek). Tools: synap_list_models (models with live per-token prices), synap_get_model, synap_estimate_cost (cost of a request before running it) and synap_chat_completion. Listing models and estimating cost need no key; chat completion takes a Synap402 API key as a Bearer token. Hosted endpoint (Streamable HTTP): https://synap402.com/mcp. Local: npx -y synap-mcp. Docs: https://synap402.com/docs

## Tools
Capabilities this server exposes over MCP:

- **synap_chat_completion** — Send a conversation to a model on Synap, Linkrra's OpenAI-compatible inference API, and get the model's reply. Use this when you need text generated, code written or a question answered by one of the open models Synap serves. This is the only tool here that costs money: it bills prompt and completion tokens to the Synap API key supplied as the Authorization: Bearer header on the MCP connection. With no key it returns an error and nothing is spent; a key with no balance returns insufficient_credits. Call synap_estimate_cost first if the price matters. Returns the standard OpenAI chat.completion JSON (choices[0].message.content holds the reply, usage holds token counts). The call is not streamed and keeps no memory between calls — send the full message history each time.
- **synap_list_models** — List the models Synap serves right now, each with its price per million tokens, context window and what it is good at. Use this to choose a model id before calling synap_chat_completion, or to compare prices. Free, read-only, no API key needed, and safe to call repeatedly; the list is live, so models can appear or go between calls. Returns {"object":"list","count":N,"data":[{id,name,capability,tier,context_tokens,max_output_tokens,pricing,data_policy}]}; pricing is USD per million prompt and completion tokens and is absent for the auto-routing ids ("synap-v1"), which bill at the price of the model they route to. For every field of one model use synap_get_model.
- **synap_get_model** — Return the complete catalogue record for one Synap model: pricing, context and output limits, supported parameters, quantisation, data-retention policy and readiness. Use this after synap_list_models when you need details the summary leaves out. Free, read-only and needs no API key. Returns the raw model object, or an error naming the id if Synap does not serve it.
- **synap_estimate_cost** — Work out what a chat completion would cost on Synap from token counts, using the live price list. Use this before synap_chat_completion when budget matters, or to compare models for a job. Free, read-only, needs no API key and runs no model. Returns {model, prompt_tokens, completion_tokens, prompt_usd, completion_usd, total_usd, pricing}. It is an estimate: the real charge uses the token counts the model reports afterwards. Auto-routing ids such as "synap-v1" have no fixed price and return an error saying so.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "synap402": {
    "command": "npx",
    "args": ["-y","synap-mcp"],
    "env": {
      "SYNAP_API_KEY": ""
    }
  }
}
```

**Requires environment variables:** `SYNAP_API_KEY` — the values above are empty placeholders; fill in real credentials before running (see the repository for what each one is for).

## Documentation

## What Synap402 does

Synap402 exposes Linkrra Synap’s open-model inference API through MCP. The available models include families such as Qwen, gpt-oss, Gemma, GLM, and DeepSeek. Agents can inspect the live catalogue, compare token prices, check model limits, estimate a request’s cost, and submit conversations for completion.

The server separates free catalogue operations from inference. Listing models, retrieving a model record, and estimating a completion cost do not require an API key and do not run a model. Chat completion is the billable operation: it uses the Synap API key supplied as a Bearer token and charges for prompt and completion tokens.

## How it works

A client can call `synap_list_models` to obtain currently served model IDs, capabilities, context sizes, output limits, tiers, pricing, and data-policy information. Because the catalogue is live, the available set can change between calls. `synap_get_model` returns the full record for one model, including supported parameters, quantisation, readiness, pricing, token limits, and retention policy.

For budget checks, `synap_estimate_cost` calculates prompt, completion, and total USD amounts from token counts and the live price list. The estimate is not the final charge; the eventual request uses the token counts reported by the model. Auto-routing IDs such as `synap-v1` have no fixed price and cannot be estimated with this tool.

`synap_chat_completion` accepts the conversation and selected model, then returns a standard OpenAI `chat.completion` response. The reply is available in `choices[0].message.content`, with token usage in `usage`. Requests are not streamed, and the server keeps no conversation memory, so each call must include the complete message history.

## Setup and configuration

Use the hosted Streamable HTTP endpoint at `https://synap402.com/mcp` when the MCP client can connect to a remote server. For a local launch, run the npm package with:

```bash
npx -y synap-mcp
```

A local client configuration can start the package and pass the credential through `SYNAP_API_KEY`:

```json
{
  "mcpServers": {
    "synap": {
      "command": "npx",
      "args": ["-y", "synap-mcp"],
      "env": { "SYNAP_API_KEY": "sk-..." }
    }
  }
}
```

The key is used for chat completion authorization. Without a key, catalogue and pricing tools remain usable, while a chat request returns an error and spends nothing. A key without sufficient balance returns `insufficient_credits`.

## Tools and capabilities

- `synap_list_models` — Lists live model IDs, capabilities, context and output limits, prices, tiers, and data policies.
- `synap_get_model` — Retrieves the complete catalogue entry for one model.
- `synap_estimate_cost` — Estimates prompt, completion, and total cost from token counts.
- `synap_chat_completion` — Sends a full conversation to a Synap model and returns an OpenAI-compatible completion.

## Limitations and notes

Chat completion is the only paid tool and is not streamed. The server does not retain conversation state, so callers must provide prior messages on every request. Prices and model availability can change because the model list is live. Auto-routing models without fixed pricing cannot be evaluated by the cost-estimation tool. A model must be selected from the models Synap currently serves; an unknown ID produces an error from the model lookup tool.

_Full upstream README: https://allmcps.com/mcp/synap402/readme_

