opencode-bridge v0.4.3

Overview

opencode-bridge is an MCP server that gives Claude Code access to OpenCode's models (GPT-5, Gemini, and others) as a companion brain. It exposes 18 tools through the Model Context Protocol, enabling multi-model consultation, code review, planning, and brainstorming directly from Claude Code sessions.

Installation

Prerequisites

• Python 3.10+
• Claude Code
• OpenCode CLI installed and available in PATH

Install the package

$ pip install opencode-bridge

Add to your MCP config

Add to ~/.claude/settings.json under mcpServers:

{
  "mcpServers": {
    "opencode-bridge": {
      "command": "opencode-bridge"
    }
  }
}

Verify

Restart Claude Code. You should see opencode_* tools available. Test with:

# In Claude Code, ask Claude to:
Use opencode_health to check the server status

MCP Tools Reference 18 tools

Auto-Framing System

When Claude sends a message via opencode_discuss, the bridge automatically constructs a structured prompt that makes OpenCode adopt an expert persona in the relevant domain.

How it works

1. The bridge receives the message and any attached files
2. File metadata is extracted (language, lines, size, category) and included as context
3. A companion prompt is assembled that instructs OpenCode to:
   • Detect the specific domain of expertise
   • Adopt the persona of a senior practitioner
   • Think out loud and share reasoning
   • Challenge assumptions and lay out trade-offs
   • Propose alternatives
4. OpenCode responds with domain identification and structured analysis

Response structure

Each auto-framed response follows this pattern:

[Domain: Architecture & System Design] [Confidence: 99%]

1. Recommendation with rationale
2. Key trade-offs
3. Risks or blind spots
4. Open questions worth exploring

Domain override

You can hint a specific domain via the domain parameter on opencode_discuss. This biases the framing without forcing it. Useful for niche fields:

# Claude will call:
opencode_discuss(
  message="How should I handle OTU clustering at 97%?",
  domain="metagenomics"
)

Follow-up messages

After the first message in a session, subsequent messages use a lightweight continuation prompt that preserves the expert context without re-sending the full framing instructions.

Chunked Processing

Files over 2,000 lines are automatically processed using a map-reduce pattern: split into overlapping chunks, each analyzed independently in parallel, then results synthesized into a single coherent response.

Parameters

Boundary snapping

Chunks don't cut at arbitrary line numbers. The splitter looks for natural code boundaries near the target cut point:

• Blank lines
• Function/class/method definitions (def, class, function, func, fn, pub fn, impl, module, package)
• Closing braces (})
• Comment lines (//, #, /*, */)

This is language-agnostic — it works for Python, JavaScript, Go, Rust, Java, C/C++, and more.

Pipeline

1. Split — file is divided into overlapping chunks with boundary snapping
2. Map — each chunk is sent to OpenCode independently (stateless, no session flag) with a focused prompt containing chunk metadata (index, line range, total chunks)
3. Reduce — all chunk analyses are sent to a synthesis prompt that merges them into one coherent response

Error handling

If some chunks fail, the synthesis still proceeds with available results. Failed chunks are marked in the synthesis prompt. If all chunks fail, raw error messages are returned. If synthesis fails, individual chunk analyses are concatenated as fallback.

Supported tools

Chunked processing is triggered by both opencode_discuss (when files are attached) and opencode_review (when file paths point to large files).

Code Review Strategies

The opencode_review tool adapts its review strategy based on the total line count of submitted files.

Language detection

opencode-bridge detects 50+ languages by file extension and includes language metadata in review prompts. Supported languages include:

Session Management

Sessions provide persistent conversation context with OpenCode. Each session tracks its model, agent, variant, and full message history.

Storage

Sessions are saved as JSON files in ~/.opencode-bridge/sessions/. They persist across server restarts.

Lifecycle

1. opencode_start — creates a new session with ID, model, agent, variant
2. opencode_discuss / opencode_plan / etc. — messages are added to the active session
3. opencode_switch — switch between existing sessions
4. opencode_export — export transcript as markdown or JSON
5. opencode_end — end the active session

Auto-start

If no session is active when opencode_discuss is called, a session is started automatically with default settings.

Configuration

Defaults are stored in ~/.opencode-bridge/config.json and can be modified with opencode_configure.

{
  "model": "openai/gpt-5.2-codex",
  "agent": "plan",
  "variant": "medium"
}

Options

Environment Variables

Environment variables take precedence over config file values.