Skip to main content
Glama
dhruv-corethink

reasoning-traces

by dhruv-corethink
OverviewSchemaRelated ServersScoreDiscussions
Python
Remote

Reasoning Traces

Give your coding agent a stronger brain to consult.

Reasoning Traces is an MCP server + Claude Code plugin. It adds a deep_reasoning tool: the agent sends a hard problem (plus the code and context it has gathered) to a stronger reasoning model, gets back the model's full reasoning trace, and uses that trace to shape and cross-check its own answer.

By default it talks to CoreThink's hosted reasoning endpoint — you only need a CoreThink API key; the reasoning model and provider are managed server-side. (Self-host / OpenRouter / Anthropic backends are also supported — see Backends.)

Install (Claude Code)

Prerequisites: uv (curl -LsSf https://astral.sh/uv/install.sh | sh) and a CoreThink API key (contact CoreThink to get one).

  1. Export your key (add to ~/.zshrc / ~/.bashrc to persist):

    export CORETHINK_API_KEY=ct-...

  2. In Claude Code:

    /plugin marketplace add dhruv-corethink/reasoning-traces
/plugin install reasoning-traces@corethink

  3. Restart Claude Code (or start a new session). Done — the plugin works in every project.

Verify with /mcp (the reasoning-traces server should be connected).

Related MCP server: Deepseek Thinker MCP Server

Usage

  • Automatic — Claude Code calls deep_reasoning on its own when a task involves multi-step reasoning (subtle bugs, architecture trade-offs, algorithm design, math). The tool description steers this.

  • On demand — force a consultation:

    /reason why does this async queue deadlock under load?

The tool result contains the reasoning model's full trace plus its conclusion; Claude Code verifies it against your actual code before answering.

Team rollout (zero-command install)

Add this to a shared repo's .claude/settings.json and every teammate gets the plugin automatically when they trust the workspace:

{
  "extraKnownMarketplaces": {
    "corethink": {
      "source": { "source": "github", "repo": "dhruv-corethink/reasoning-traces" }
    }
  },
  "enabledPlugins": { "reasoning-traces@corethink": true }
}

Each teammate still needs their own CORETHINK_API_KEY in their environment.

Configuration

The shipped plugin uses the corethink backend and needs only CORETHINK_API_KEY. The other variables apply when you switch backends (see Backends); set them in your shell or a per-project .env file (the server loads .env from the working directory; existing env vars win).

Variable

Default

Meaning

CORETHINK_API_KEY

—

Required for the default (corethink) backend

CORETHINK_BASE_URL

CoreThink Cloud Run URL

Override the reasoning endpoint (rarely needed)

REASONING_BACKEND

corethink (plugin)

corethink, openrouter, or anthropic

REASONING_EFFORT

high

low/medium/high (backend-dependent)

REASONING_MAX_TOKENS

32000

Output cap for the reasoning call

REASONING_MAX_RESULT_CHARS

32000

Truncation cap on the tool result

With the corethink backend the reasoning model is chosen server-side (Claude Opus 4.8 by default).

Other MCP clients

Any MCP client (Claude Desktop, Cursor, etc.) can run the server without the plugin:

{
  "mcpServers": {
    "reasoning-traces": {
      "command": "uvx",
      "args": ["--from", "git+https://github.com/dhruv-corethink/reasoning-traces", "reasoning-traces"],
      "env": { "REASONING_BACKEND": "corethink", "CORETHINK_API_KEY": "ct-..." }
    }
  }
}

Or with plain Claude Code CLI, no plugin:

claude mcp add --scope user reasoning-traces --env REASONING_BACKEND=corethink --env CORETHINK_API_KEY=ct-... -- uvx --from git+https://github.com/dhruv-corethink/reasoning-traces reasoning-traces

Custom backends

reasoning_traces/backends.py defines a tiny interface — reason(prompt) -> ReasoningResult(trace, conclusion). Three backends ship today (select with REASONING_BACKEND):

  • corethink (default) — CoreThink's hosted reasoning endpoint. Needs only CORETHINK_API_KEY; the upstream provider, model, and key stay server-side.

  • openrouter — any reasoning model on OpenRouter directly (OPENROUTER_API_KEY, REASONING_MODEL).

  • anthropic — Claude with adaptive thinking (ANTHROPIC_API_KEY; summarized reasoning — the Anthropic API never exposes raw chain of thought).

Development

git clone https://github.com/dhruv-corethink/reasoning-traces
cd reasoning-traces
echo "OPENROUTER_API_KEY=sk-or-v1-..." > .env   # gitignored

Open Claude Code in the repo — .mcp.json runs the server straight from source via uvx. The .env is loaded by the server at startup.

License

MIT

Available Tools

1 tool
deep_reasoningA

Consult a stronger reasoning model and get its full reasoning trace.

Call this BEFORE proposing a solution whenever the task involves multi-step reasoning: subtle bugs or race conditions, architectural trade-offs, algorithm design, math, or anything where a first instinct could be wrong. Use the returned trace to guide and cross-check your own answer.

The reasoning model cannot see this conversation — pass everything it needs.

Args: problem: The question or task, stated precisely. context: Relevant code, error output, logs, or background you have gathered. Include full snippets, not paraphrases. constraints: Hard requirements the solution must satisfy (performance, compatibility, style), if any.

ParametersJSON Schema
NameRequiredDescriptionDefault
contextNo
problemYes
constraintsNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.8/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It discloses that the tool consults a 'stronger reasoning model', returns a 'full reasoning trace', and notes that the model cannot see the conversation. While it doesn't explicitly state whether the operation is read-only or mention latency, the nature of a reasoning call implies no side effects, making the transparency adequate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and well-structured: a brief purpose statement, followed by a paragraph on usage with examples, a critical caveat, and a clear args section. Every sentence provides value without repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

An output schema exists (not shown but noted), so the description need not explain return values. Despite having no sibling tools, the description covers purpose, usage, parameters, and a critical limitation. For a tool with 3 parameters and no annotations, this is a complete and informative description.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It fully documents each parameter: 'problem: The question or task, stated precisely.'; 'context: Relevant code, error output, logs, or background... Include full snippets, not paraphrases.'; 'constraints: Hard requirements...' This adds significant meaning beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Consult a stronger reasoning model and get its full reasoning trace.' It uses a specific verb and resource, and distinguishes this tool from any hypothetical alternatives by specifying its role in multi-step reasoning tasks.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says 'Call this BEFORE proposing a solution whenever the task involves multi-step reasoning...' and lists concrete examples (subtle bugs, architectural trade-offs, etc.). It also includes a critical limitation: 'The reasoning model cannot see this conversation — pass everything it needs.' This provides clear when-to-use and how-to-use guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. 1 tool updatev0.1.0
    • First observeddeep_reasoning
Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.6/5.0
Disambiguation5/5

With only one tool, there is no ambiguity. The tool's purpose is clearly defined and distinct from anything else.

Naming Consistency5/5

The single tool uses a clear, descriptive snake_case name that is consistent within itself and standard for MCP tools.

Tool Count3/5

One tool is below the typical 3-15 range but suits the narrow purpose of providing reasoning traces. It feels thin but not inappropriate.

Completeness4/5

The tool covers the core functionality of retrieving a reasoning trace with necessary parameters. Minor gaps exist, such as lacking model selection, but it is largely complete for its stated purpose.

Maintenance

ActivitySlowing
ResponsivenessSyncing

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/dhruv-corethink/reasoning-traces'

If you have feedback or need assistance with the MCP directory API, please join our Discord server