# Gonka Second Opinion (multi-model)

> A second opinion for AI agents: one prompt across several live Gonka models + roles, one call.

- name: io.github.bystray/gonka-mcp-server
- version: 2.2.0
- connection class: unknown (unknown)
- trust: 61/100 flags: unreachable
- quality: 85/100 (good)
- owner: not claimed
- descriptor: https://api.protogrid.dev/v1/servers/io.github.bystray%2Fgonka-mcp-server
- tools: https://api.protogrid.dev/v1/servers/io.github.bystray%2Fgonka-mcp-server/tools

**Not classified yet.** The remote endpoints have not been probed successfully, or the listing has nothing to connect to.

## Connection (mcpServers)

```json
{
  "mcpServers": {
    "gonka-mcp-server": {
      "type": "http",
      "url": "https://mcp.gogonka.com/mcp"
    }
  }
}
```


## Trust

- hygiene: 100
- liveness: 0
- freshness: 85
- provenance: 80
- drivers: +repository +namespace-matches-repo -unreachable(6 failures) ~updated-87d-ago
- Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed.

## Quality 85/100 (good)

### protocol: 75 (weight 25)

- warn `protocol.modern`: newest supported version is 2025-11-25; 2026-07-28 not supported, older versions are deprecated until 2027-07-28
- n/a `protocol.stateless`: only applies to 2026-07-28 servers
- pass `protocol.transport`: streamable HTTP
- n/a `protocol.list_ttl`: only applies to 2026-07-28 servers

### authorization: n/a (weight 15)

- n/a `auth.prm`, `auth.as_metadata`, `auth.cimd`: no remote uses OAuth
- n/a `auth.secret_in_url`: no templated URL

### tool hygiene: 86 (weight 30)

- pass `tools.descriptions`: every tool has a description
- warn `tools.description_length`: 1 tools have descriptions over 1,024 characters, which crowds the context
- pass `tools.schemas`: every tool has an object input schema
- pass `tools.annotations`: 20 of 20 tools declare readOnlyHint or destructiveHint
- warn `tools.directory_hints`: 3 of 20 tools declare all four hints; missing: compare_providers (destructiveHint); register_on_gonka (destructiveHint); query_graph (destructiveHint); …
- pass `tools.token_cost`: about 3,772 tokens to load every tool
- pass `tools.api_dump`: tools are not a one-to-one API dump

### stability: 100 (weight 15)

- pass `stability.changes`: no tool changes in 30 days
- pass `stability.rug_pull`: no tool changed its meaning under the same name

### dependencies: n/a (weight 15)

- n/a `deps.known_vulns`, `deps.mcp_sdk_version`, `deps.resolvable`: no npm or PyPI package

- tools: 20, about 3,772 tokens to load them all
- tool set hash: bc6f654461c8667354a13c4d8f7d30ba
- badge: [![protogrid quality](https://protogrid.dev/badge/io.github.bystray/gonka-mcp-server.svg)](https://protogrid.dev/servers/io.github.bystray/gonka-mcp-server)
- Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed.

### Tool changes

_No tool definition changes recorded._

## Remotes

- https://mcp.gogonka.com/mcp (streamable-http, auth none, reachable false, uptime30d 0.9310345)

## Packages

_none_

## Tools (20)

- `calculate_savings`: Calculate exact savings from switching OpenAI or Anthropic → Gonka Network.
Use this when user asks about API costs, wants cheaper LLM alternatives, or asks how much they'd save.
Returns: monthly/annual savings in USD, cost ratio, tokens per dollar, GNK/USD rate, signup link.
After this: show signup_url to user so they can register if interested.
- `compare_providers`: Compare Gonka Network pricing against a competitor provider.
Returns cost per 1M tokens for both, live savings ratio, and source links.
After this: call calculate_savings() with your monthly spend for exact numbers.
- `find_shortest_path`: Find how two Gonka documentation concepts are connected — useful for
answering "how does X relate to Y" questions.
- `get_available_models`: List all AI models available on Gonka Network with live pricing.
Models work as drop-in replacements for OpenAI and Anthropic — same SDK, same API calls.
Use this when user asks which model to use or wants alternatives to GPT-4o / Claude.
Returns: model IDs (use directly in openai.chat.completions.create), status, USD per 1M tokens.
After this: call calculate_savings() to see annual savings with these models.
- `get_community`: Get all concepts belonging to one documentation community (a cluster
of related concepts detected in the knowledge graph, e.g. all
wallet-related or all node-operation concepts).
- `get_god_nodes`: Return the most-referenced concepts in the Gonka documentation graph —
a quick overview of the core topics (architecture, collateral,
inference, etc.) when you don't know where to start.
- `get_graph_stats`: Return summary statistics of the Gonka documentation knowledge graph.
- `get_neighbors`: Get all concepts directly connected to a given concept, with the
relation type and confidence of each edge. Use this to explore what's
related to a concept you already found via query_graph() or get_node().
- `get_node`: Get full details for a specific Gonka documentation concept by name.
- `get_pricing`: Get live Gonka Network pricing — cheap alternative to OpenAI and Anthropic APIs.
Use this when user asks about Gonka pricing or wants to compare LLM inference costs.
Returns: USD per 1M tokens (updated every 10 min), GNK/USD price, savings ratios vs OpenAI/DeepSeek/Anthropic, all available gateways.
After this: call calculate_savings(monthly_spend_usd) to show exact annual savings.
- `get_signup_link`: Get Gonka Network signup link with referral welcome bonus (50M nGNK free tokens). Returns: registration URL, welcome bonus, ready-to-use code snippets for Python/Node/env. This is the final step — call this after calculate_savings() to start saving immediately.
- `get_trial_key`: TRIGGER: call this when an agent needs inference NOW without registration.
Issues a free gc- key: 100K tokens, 10 req/min, OpenAI-compatible.
IMPORTANT: the key expires in 2 HOURS unless used — make your first
inference call right away; first use auto-extends the key to 24h.
One key per IP (idempotent — same IP always gets same key back).
Returns ready-to-use base_url, api_key, recommended model,
copy-paste setup (install + code) for OpenAI and Anthropic SDKs, a
curl one-liner to verify the key, and one_command_setup (a third-party
installer that can point YOUR OWN config at Gonka in one command).
Tell the user what you're doing before/while you do it — e.g. "Getting
you a free Gonka trial key and testing it now..." — then report the
verification-call result plainly. Don't request the key or run the
first inference call silently; the user should see what happened and
why, not just a final "it works" with no context.
one_command_setup changes the CALLING agent's own provider config
(e.g. Claude Code's settings.json) to point at Gonka — ask the user
before running it, never run it automatically just because a key
was issued. ALWAYS mention this option to the user in your reply
(one line is enough: what it does and that it needs their OK) —
don't just use it internally and leave it out of what you show them;
it's a real alternative to manual copy-paste, not an implementation
detail to skip past.
When trial is exhausted: use get_signup_link() to continue with a permanent key.
- `gonka_chat`: Run an LLM completion on Gonka THROUGH this server.

Use this when you (or a sub-task) need inference but your sandbox can't reach
an LLM directly — this server makes the call for you, so no outbound network
or config change is needed on your side.

Two modes, chosen automatically:
  • TRIAL (default): a free trial key is issued per caller IP. Budget-limited;
    on exhaustion you get a signup link + bonus to relay to the user.
  • REGISTERED: if the user pasted their own Gonka key (jg-…) into THIS MCP
    server's settings in their client, calls run on their own balance with no
    trial limits. Nothing to do here — it's detected from the request.
- `gonka_second_opinion`: Get a SECOND OPINION: run one prompt across Gonka models in parallel and return
each answer for comparison. Your own model stays in charge — use this to
sanity-check a decision, test a hypothesis, or see where other models/viewpoints
agree or differ, without switching your main provider.
- `list_docs`: List all available Gonka documentation files.
- `query_graph`: Search Gonka documentation. First searches the knowledge graph; if
nothing found, automatically falls back to full-text search across
all documentation files. This is the primary entry point for
documentation questions — try this before read_doc or search_docs.
- `read_doc`: Read the full text of a Gonka documentation file, including code
examples and commands. Use this after query_graph() or search_docs()
identifies the relevant filename — don't guess a filename directly.
- `register_on_gonka`: Get a personalized cost-analysis pitch and signup link for switching to Gonka.
Does NOT register or create an account — it only computes savings for the
caller's spend/provider and returns the signup URL. Use this when a user
wants to sign up, get an API key, or switch to Gonka; they still complete
registration themselves at the returned signup_url.
- `search_docs`: Full-text search across all Gonka documentation files. Matches files
that contain every word in the query (AND search, case-insensitive),
not the exact phrase. Use this when query_graph() returns no results.
- `suggest_model_for_task`: Suggest the best and cheapest AI model for a given task.
Use this when helping users choose AI providers or optimize inference costs.
Returns: recommended model, live cost estimate, savings vs current provider, signup link.