Zum Hauptinhalt springen
OpenCode ist ein quelloffener KI-Coding-Agent für Entwickler und setzt auf eine „terminal-native“ Erfahrung: Über TUI/CLI lassen sich Workflows wie Anforderungsbesprechung, Codegenerierung, Refactoring, Erklärung und Debugging direkt in der Befehlszeile erledigen. OpenCode ist „modellunabhängig“ konzipiert und kann an Modelldienste wie Claude, GPT und Gemini angebunden werden. Außerdem unterstützt es lokale oder OpenAI-kompatible Schnittstellen, sodass sich Kosten, Ergebnisqualität und Datenschutz flexibel gegeneinander abwägen lassen. OpenCode bietet zudem erweiterbare Plugin-/Tool-Mechanismen sowie ein Konfigurationssystem, mit dem sich Projektkontext, Befehlsausführung und weitere Fähigkeiten in automatisierte Abläufe integrieren lassen. Es eignet sich besonders für intensive Terminal-Nutzer und Teams, die eigene KI-gestützte Programmier-Workflows anpassen möchten.

Installation und Anbindung

Installation

curl -fsSL https://opencode.ai/install | bash
Weitere Installationsmethoden findest du auf der offiziellen OpenCode-Website: https://opencode.ai/docs/#install

OpenCode starten

cd /path/to/project  # Zum Projektpfad wechseln

opencode  # OpenCode starten

JieKou API anbinden

  • Globale Konfiguration: ~/.config/opencode/opencode.json
  • Projektkonfiguration: opencode.json im Stammverzeichnis des Projekts
(Falls keine opencode.json vorhanden ist, kannst du sie manuell erstellen.) Die Konfiguration lautet wie folgt:
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "myprovider": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "JieKou",
      "options": {
        "baseURL": "https://api.highwayapi.ai/openai/v1"
      },
      "models": {
        "claude-sonnet-4-5-20250929": {
          "name": "claude-sonnet-4-5-20250929"
        },
        "gpt-5.2": {
          "name": "gpt-5.2"
        },
      }
    }
  }
}
Beim Konfigurieren eines Drittanbieters musst du darauf achten, das richtige npm-Paket auszuwählen:
npm-PaketAPI-TypGeeignet für
@ai-sdk/openai-compatibleChat Completion APIGPT, Claude und die meisten anderen Modelle
@ai-sdk/openaiResponse APIModelle der Codex-Reihe
Hinweis: Codex-Modelle (z. B. gpt-5.1-codex) müssen @ai-sdk/openai (Response API) verwenden; andere Modelle verwenden @ai-sdk/openai-compatible (Chat Completion API).

KEY konfigurieren

Öffne opencode, wähle mit /connect den Anbieter aus, gib den API KEY ein und bestätige mit Enter. opencode_input_api_key

Erste Schritte

Nachdem der Anbieter verbunden ist, kannst du mit dem Befehl /models ein Modell auswählen. opencode_choose_model

Weitere Verwendung

Beispiel: Lokale MCP-Konfiguration (am Beispiel eines Rechner-MCP)

  1. Schreibe mit python + MCP SDK den Code für einen Rechner-mcp-server und speichere ihn in einem lokalen Pfad.
import asyncio
import math
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent

# Create server instance
server = Server("calculator")

@server.list_tools()
async def list_tools() -> list[Tool]:
    """List available calculator tools."""
    return [
        Tool(
            name="add",
            description="Add two numbers",
            inputSchema={
                "type": "object",
                "properties": {
                    "a": {"type": "number", "description": "First number"},
                    "b": {"type": "number", "description": "Second number"},
                },
                "required": ["a", "b"],
            },
        ),
        Tool(
            name="subtract",
            description="Subtract second number from first number",
            inputSchema={
                "type": "object",
                "properties": {
                    "a": {"type": "number", "description": "First number"},
                    "b": {"type": "number", "description": "Second number to subtract"},
                },
                "required": ["a", "b"],
            },
        ),
        Tool(
            name="multiply",
            description="Multiply two numbers",
            inputSchema={
                "type": "object",
                "properties": {
                    "a": {"type": "number", "description": "First number"},
                    "b": {"type": "number", "description": "Second number"},
                },
                "required": ["a", "b"],
            },
        ),
        Tool(
            name="divide",
            description="Divide first number by second number",
            inputSchema={
                "type": "object",
                "properties": {
                    "a": {"type": "number", "description": "Dividend"},
                    "b": {"type": "number", "description": "Divisor"},
                },
                "required": ["a", "b"],
            },
        ),
        Tool(
            name="power",
            description="Raise a number to a power",
            inputSchema={
                "type": "object",
                "properties": {
                    "base": {"type": "number", "description": "Base number"},
                    "exponent": {"type": "number", "description": "Exponent"},
                },
                "required": ["base", "exponent"],
            },
        ),
        Tool(
            name="sqrt",
            description="Calculate square root of a number",
            inputSchema={
                "type": "object",
                "properties": {
                    "a": {"type": "number", "description": "Number to calculate square root of"},
                },
                "required": ["a"],
            },
        ),
        Tool(
            name="modulo",
            description="Calculate remainder of division",
            inputSchema={
                "type": "object",
                "properties": {
                    "a": {"type": "number", "description": "Dividend"},
                    "b": {"type": "number", "description": "Divisor"},
                },
                "required": ["a", "b"],
            },
        ),
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
    """Handle tool calls for calculator operations."""
    try:
        if name == "add":
            result = arguments["a"] + arguments["b"]
        elif name == "subtract":
            result = arguments["a"] - arguments["b"]
        elif name == "multiply":
            result = arguments["a"] * arguments["b"]
        elif name == "divide":
            if arguments["b"] == 0:
                return [TextContent(type="text", text="Error: Division by zero")]
            result = arguments["a"] / arguments["b"]
        elif name == "power":
            result = math.pow(arguments["base"], arguments["exponent"])
        elif name == "sqrt":
            if arguments["a"] < 0:
                return [TextContent(type="text", text="Error: Cannot calculate square root of negative number")]
            result = math.sqrt(arguments["a"])
        elif name == "modulo":
            if arguments["b"] == 0:
                return [TextContent(type="text", text="Error: Modulo by zero")]
            result = arguments["a"] % arguments["b"]
        else:
            return [TextContent(type="text", text=f"Error: Unknown tool '{name}'")]

        return [TextContent(type="text", text=str(result))]

    except Exception as e:
        return [TextContent(type="text", text=f"Error: {str(e)}")]

async def main():
    """Run the calculator MCP server."""
    async with stdio_server() as (read_stream, write_stream):
        await server.run(read_stream, write_stream, server.create_initialization_options())

if __name__ == "__main__":
    asyncio.run(main())

  1. Füge in opencode.json ein lokales mcp hinzu.
{
  "mcp": {
    "calc_mcp": {
      "type": "local",
      "command": ["python3", "{your_local_path}/calc_mcp.py"],
      "enabled": true
    }
  }
}
  1. Prüfe mit /mcps den mcp-Verbindungsstatus. Wenn der Status Enabled ist, kannst du opencode zum Aufrufen verwenden.
opencode_mcp