Nexus-CLI – Pure Go Bridge to DeepSeek R1/V3 with Claude Code and Ollama

Open-source developer xamrayev released Nexus-CLI, a Golang command-line tool and local API proxy connecting applications to DeepSeek V3 and DeepSeek R1 via standard web accounts. As detailed in github.com's report, the utility enables engineers to query deepseek-chat and deepseek-reasoner models without paying for official API keys. Built in pure Go with zero runtime dependencies, the software includes a parallel proof-of-work solver and an internal proxy that bridges web chat sessions into standard interfaces for development tools. This bridge translates browser interactions into local endpoints.

This review examines the architecture, protocol adapters, deployment steps, and platform limitations of Nexus-CLI for software engineers and command-line developers. The analysis details how the Go binary processes server challenges, exposes OpenAI, Anthropic, and Ollama endpoints, and rotates multiple user accounts. It provides terminal setup commands, configuration instructions for AI coding agents such as Claude Code and Aider, and diagnostic checks. Technical teams evaluating local reasoning workflows without subscription overhead can assess whether this proxy meets their integration and testing requirements.

What shipped in Nexus-CLI – Pure Go Bridge to DeepSeek R1/V3

The package arrives as a unified binary operating as an interactive terminal client, command runner, and proxy server. In terminal mode, the interactive REPL streams DeepSeek R1 thought processes in real time using italic cyan ANSI styling and animated loading spinners. Users can control active sessions with built-in slash commands including /help, /new, /model, /thinking, /search, /whoami, /clear, and /exit. For automated shell workflows, the utility accepts one-off queries and standard Unix pipes, allowing developers to pipe source files into prompts for rapid code reviews and security inspections.

For background execution, the utility includes a local proxy launched through the nexus serve command on port 9655. This server handles OpenAI Chat Completions over POST /v1/chat/completions, Anthropic Messages over POST /v1/messages, and OpenAI Responses over POST /v1/responses. It also serves GET /v1/models, GET /v1/model-capabilities, GET /v1/sessions, and POST /v1/sessions/reset. Complementing these routes is native Ollama API emulation supporting GET /api/tags, POST /api/chat, POST /api/generate, and GET /api/version. Preconfigured launchers automate starting the background proxy for Claude Code, the official DeepSeek Harness CLI, OpenAI Codex CLI, OpenCode, Block Goose AI, and Aider.

What improved in Nexus-CLI – Pure Go Bridge to DeepSeek R1/V3

The codebase replaces older community bridges built with Node.js in FreeDeepseekAPI-EN and Python in deepseek_bridge with a zero-dependency Go implementation. A key technical advancement is the parallel Proof-of-Work solver that resolves DeepSeek server challenges using the DeepSeekHashV1 algorithm across CPU cores. The algorithm executes Keccak-f[1600] operations across 1 to 23 rounds of SHA3-256 without CGO, WASM, or Python dependencies. By parallelizing these cryptographic loops, the engine solves difficulty 144,000 challenges in 40 to 50 milliseconds, eliminating connection lag and simplifying setup across developer machines.

Account management and resilience have also advanced beyond single-session setups. To mitigate HTTP 429 rate limits, Nexus-CLI includes a multi-account pool that rotates queries across registered accounts using Round-Robin scheduling. Token collection is supported through manual browser LocalStorage extraction or automated session token extraction from browser memory using Chrome DevTools Protocol. The software also provides the nexus doctor command, an integrated diagnostic runner that systematically validates user tokens, tests server reachability, benchmarks challenge solving latency, and verifies session creation before external agents connect.

What you gain from Nexus-CLI – Pure Go Bridge to DeepSeek R1/V3

Engineers gain zero-cost integration with DeepSeek V3 and DeepSeek R1 reasoning models across their preferred development environments. Because the proxy emulates the Anthropic Messages API on POST /v1/messages, tools like Claude Code can run DeepSeek models directly without modifying source code or subscribing to commercial API plans. Native Ollama emulation enables tools like Open WebUI, Dify, AnythingLLM, Cursor, LlamaIndex, and the official Ollama Python SDK to point to localhost:9655 without extra adapter layers, providing access to deepseek-reasoner thought streams alongside deepseek-chat responses.

The release also provides strict structured output controls, enabling validation against JSON Schemas across CLI, Ollama, and OpenAI endpoints. CLI queries formatted with the json argument pipe cleanly into utilities like jq for automated parsing in shell scripts. Unix pipe workflows allow developers to stream codebase files directly into prompts for rapid analysis of security vulnerabilities and performance bottlenecks. By pairing these output guarantees with Round-Robin account pooling, teams gain a dependable local gateway that protects testing workflows from sudden HTTP 429 throttling errors.

How to get Nexus-CLI – Pure Go Bridge to DeepSeek R1/V3

Setting up Nexus-CLI requires a system with Go 1.20 or newer installed. Developers clone the repository from GitHub, compile the source code using the Go compiler to generate the binary in the bin directory, and optionally install it to the system path. Once installed, users link their DeepSeek account by running the interactive login command and pasting the userToken from browser LocalStorage at chat.deepseek.com, or by using the automated Chrome login helper. Alternatively, users can set the token directly in a local environment file.

git clone https://github.com/xamrayev/nexus-cli.git
cd nexus-cli
go build -o bin/nexus .
go install .

./bin/nexus auth login
./bin/nexus auth chrome

/model
/thinking

./bin/nexus launch claude
./bin/nexus launch claude -p "Refactor this Go code"
./bin/nexus launch codex
./bin/nexus serve --port 9655

After authenticating, users can start the local API proxy server on default port 9655 or launch integrated coding tools with dedicated launcher commands. Inside the interactive terminal REPL, developers switch models and toggle reasoning output using built-in slash commands such as /model and /thinking. For multi-account configurations, operators add secondary accounts with the auth add command, switch profiles using auth switch, and verify pool readiness via auth test. Finally, running the nexus doctor command verifies token validity, connection status, challenge solver speed, and session initialization before routing production traffic.

What to watch after Nexus-CLI – Pure Go Bridge to DeepSeek R1/V3

Because Nexus-CLI relies on web account session tokens and the chat.deepseek.com web interface rather than a documented enterprise API, upstream changes represent an ongoing operational risk. If DeepSeek updates authentication parameters, modifies the DeepSeekHashV1 algorithm, or increases Proof-of-Work difficulty thresholds, the solver may fail until the codebase is updated. Session tokens extracted from browser storage also expire periodically, requiring users to repeat authentication steps to avoid HTTP 401 and 403 errors. While Round-Robin rotation reduces per-account traffic, excessive request spikes can still trigger web rate limits or account scrutiny.

Engineers must also consider operational latency and data handling boundaries when routing development tools through web-based proxies. Although the Go solver processes challenges in 40 to 50 milliseconds, web infrastructure response times remain subject to server load and network conditions on chat.deepseek.com. Organizations handling proprietary code should note that queries pass through standard consumer web accounts without enterprise privacy agreements. Development teams should use the doctor diagnostic suite regularly, maintain pinned binary builds, and monitor repository updates across the pkg/deepseek and pkg/server modules as community maintainers track changes to DeepSeek web protocols.