DEV Community: Omachoko Tanimu Yakubu

Hacking the Brain: How I Built a Custom Proxy to Run Claude Code on Gemini 2.0 Flash (For Free)

Omachoko Tanimu Yakubu — Mon, 11 May 2026 15:37:28 +0000

The Hook: The $500 Question

We’ve all seen the demo: Claude Code is a beast. It’s an agentic CLI that doesn’t just suggest code; it lives in your terminal, runs bash commands, searches your filesystem, and executes complex multi-step audits.

But for those of us in the Web3 and Cybersecurity space, the native Anthropic API comes with three massive friction points:

Aggressive Rate Limits on the Opus/Sonnet tiers.
High Token Costs when analyzing 100k+ line smart contract repos.
Regional Geofencing that can kill your workflow mid-audit.

I wanted the interface of Claude Code, the brain of Gemini 2.0 Flash (with its massive 1M context window), and the pricing of OpenRouter (currently $0.00 for Gemini 2.0 Flash).

This is the story of how I hacked the protocol to make it happen.

The Conflict: Why Standard Routers Fail

I started where most do: the community-built @musistudio/claude-code-router (ccr). It’s a great project, but in the trenches of a Linux environment, it hit a wall.

The "Provider Not Found" errors and the lack of deep-packet inspection meant that Claude Code’s hidden "power features"—like Prompt Caching and Strict Tool Selection—were actually breaking the connection to OpenRouter.

Specifically, we were getting slammed with HTTP 400 Errors from Amazon Bedrock. Why? Because Claude Code was sending cache_control tags that Bedrock didn't understand. The standard router was just a postman; it wasn't a translator.

The Deep Dive: The Three Pillars of the "God-Mode" Proxy

To solve this, I moved away from pre-built tools and engineered a custom Node.js Universal Translator Proxy. Here is the technical architecture that solved the puzzle:

1. The "Deep-Clean" Logic

Claude Code is opinionated. It injects cache_control: {"type": "ephemeral"} into its payloads. Most OpenRouter providers see this and panic. My proxy implements a recursive cleaner that scrubs these tags before the data ever leaves your machine.

2. Protocol Translation (Anthropic ↔ OpenAI)

This was the hardest part. Anthropic uses a specific Server-Sent Events (SSE) format for streaming. OpenAI/OpenRouter uses another. If you get this wrong, you get the dreaded "Empty or Malformed Response (HTTP 200)". My proxy translates the "Typewriter" effect in real-time, making Gemini feel like a native Claude model.

3. Agentic Continuity

Claude Code isn't just one message; it's a conversation. When the AI runs a tool (like ls or grep), it needs to see that tool's result in its history. My proxy maps these "Tool Results" back into the OpenAI tool role, ensuring the AI never loses its train of thought.

The Blueprint: How to Replicate This Setup

Step 0: Prerequisites & Installation

Before we touch the proxy, ensure you have the core tools installed. Open your terminal and run:

# 1. Install Node.js (if not already present)
# On Debian/Ubuntu/Parrot:
sudo apt update && sudo apt install -y nodejs npm

# 2. Install Claude Code globally
npm install -g @anthropic-ai/claude-code

# 3. Create your proxy directory
mkdir ~/claude-code-proxy && cd ~/claude-code-proxy

**Note**: You do NOT need to "install" OpenRouter. It is a cloud API that we communicate with via HTTP requests. As long as you have Node.js, you're ready.

Step 1: The Environment

Forget the complex JSON configs. All you need is three lines in your .bashrc or .env:

# Point Claude to your local bridge
export ANTHROPIC_BASE_URL=http://localhost:3456/v1
# Use your OpenRouter Key
export ANTHROPIC_API_KEY=sk-or-v1-xxxx...
# Tell Claude to use a "Sonnet" name (the proxy will swap the brain)
export CLAUDE_CODE_MODEL=claude-3-5-sonnet-20240620

Step 2: The Proxy (The Secret Sauce)

This is the final, battle-tested script. Save it as ~/proxy.js to enable full agentic capabilities:

const http = require('http');

const API_KEY = 'YOUR_OPENROUTER_KEY';
const TARGET_MODEL = 'google/gemini-2.0-flash-001'; 

http.createServer(async (req, res) => {
  let body = '';
  for await (const chunk of req) body += chunk;
  if (!body) return res.end();

  try {
    const incoming = JSON.parse(body);
    const messages = [];

    // History Translation
    incoming.messages.forEach(m => {
      if (Array.isArray(m.content)) {
        const toolCalls = m.content.filter(c => c.type === 'tool_use');
        const textContent = m.content.filter(c => c.type === 'text').map(c => c.text).join('\n');
        const toolResults = m.content.filter(c => c.type === 'tool_result');
        if (m.role === 'assistant') {
          const msg = { role: 'assistant', content: textContent || null };
          if (toolCalls.length > 0) {
            msg.tool_calls = toolCalls.map(tc => ({
              id: tc.id, type: 'function',
              function: { name: tc.name, arguments: JSON.stringify(tc.input) }
            }));
          }
          messages.push(msg);
        } else {
          if (toolResults.length > 0) {
            toolResults.forEach(tr => {
              messages.push({ role: 'tool', tool_call_id: tr.tool_use_id, content: typeof tr.content === 'string' ? tr.content : JSON.stringify(tr.content) });
            });
          }
          if (textContent || toolResults.length === 0) messages.push({ role: 'user', content: textContent || "" });
        }
      } else {
        messages.push({ role: m.role === 'assistant' ? 'assistant' : 'user', content: m.content });
      }
    });

    const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${API_KEY}`, 'HTTP-Referer': 'https://github.com/anthropic-ai/claude-code' },
      body: JSON.stringify({
        model: TARGET_MODEL,
        messages: messages,
        tools: incoming.tools ? incoming.tools.map(t => ({ type: 'function', function: { name: t.name, description: t.description, parameters: t.input_schema } })) : undefined,
        stream: true
      })
    });

    res.writeHead(200, { 'Content-Type': 'text/event-stream', 'anthropic-version': '2023-06-01' });

    const reader = response.body.getReader();
    const decoder = new TextDecoder();

    res.write(`event: message_start\ndata: {"type":"message_start","message":{"id":"msg_${Date.now()}","type":"message","role":"assistant","content":[],"model":"claude-3-5-sonnet-20240620","stop_reason":null,"usage":{"input_tokens":0,"output_tokens":0}}}\n\n`);
    res.write(`event: content_block_start\ndata: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}\n\n`);

    let toolCallsDelta = {};

    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      const chunks = decoder.decode(value).split('\n');
      for (const chunk of chunks) {
        if (!chunk.startsWith('data: ')) continue;
        const line = chunk.slice(6);
        if (line === '[DONE]') continue;
        try {
          const json = JSON.parse(line);
          const delta = json.choices[0].delta;
          if (delta.content) {
            res.write(`event: content_block_delta\ndata: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":${JSON.stringify(delta.content)}}}\n\n`);
          }
          if (delta.tool_calls) {
            delta.tool_calls.forEach(tc => {
              if (!toolCallsDelta[tc.index]) toolCallsDelta[tc.index] = { id: tc.id, name: tc.function.name, input: '' };
              if (tc.function.arguments) toolCallsDelta[tc.index].input += tc.function.arguments;
            });
          }
        } catch (e) {}
      }
    }

    for (const index in toolCallsDelta) {
      const tc = toolCallsDelta[index];
      res.write(`event: content_block_start\ndata: {"type":"content_block_start","index":${parseInt(index)+1},"content_block":{"type":"tool_use","id":"${tc.id}","name":"${tc.name}","input":${tc.input || '{}'}}}\n\n`);
    }

    res.write(`event: message_stop\ndata: {"type":"message_stop"}\n\n`);
    res.end();

  } catch (e) {
    res.statusCode = 500; res.end();
  }
}).listen(3456);

Step 3: Launching the Environment

To get your new agentic setup running, you will need two terminal sessions:

Terminal 1: The Proxy Bridge
First, clear any old processes and start your translator.

# Kill any existing process on our port
sudo fuser -k 3456/tcp
# Launch the proxy in the background
node ~/proxy.js &

Terminal 2: The Agent
Now, simply launch Claude Code as you normally would. It will automatically route through your bridge.

claude

The Verdict: Total Agentic Power

Once this bridge was built, the results were staggering. I asked Claude to:

List all .txt files in my home directory. (It succeeded using ls.)
Study a complex Web3 workspace (glider-poc). (It correctly identified the Foundry setup, Solidity audits, and Polygon AggLayer integration.)
Spawn sub-agents. (The sub-agents worked perfectly, summarizing massive markdown files.)

Why This Matters

For Python Developers and AI Engineers, this represents the democratization of agentic tools. You are no longer tethered to a single provider's credits or their regional whims. You have built a universal adapter.

In Cybersecurity, we often say that "the best defense is a deep understanding of the protocols." Today, we didn't just use a tool—we understood the API protocol well enough to rewrite it.

Are you ready to hack your workflow?

Find the repository for easy setup and future updates on my GitHub: https://github.com/OmachokoYakubu/claude-code-proxy, and let's build the future of AI-assisted security together.

Omachoko Yakubu

CYBERSECURITY ANALYST (WEB2/WEB3) | PYTHON DEVELOPER & AI/LLM ENGINEER

HNG12 STAGE 1: NUMBER CLASSIFICATION API DEVELOPMENT & DEPLOYMENT

Omachoko Tanimu Yakubu — Wed, 05 Feb 2025 16:34:16 +0000

INTRODUCTION

The task required the development of an API that classifies numbers based on mathematical properties and provides a fun fact retrieved from an external API. The API must return data in JSON format, be deployed publicly, and adhere to quality standards. The acceptance criteria ensure the API is functional, well-documented, and efficiently deployed.

I then proceeded to update the package list and installed necessary system tools to ensure a smooth development environment. I ran the following commands:

sudo apt update && sudo apt upgrade -y
sudo apt install python3 python3-pip git curl -y

This ensured that Python, Pip, Git, and Curl were available for use.

SETTING UP THE PROJECT DIRECTORY

I created a dedicated directory for the project and navigated into it:

mkdir number_api && cd number_api

Having created the directory I installed FastAPI and Uvicorn, which will serve as the API framework and ASGI server respectively:

pip install fastapi uvicorn requests

This step ensures that the necessary libraries are available for developing and running the API.

WRITING THE API CODE

Using a text editor, I created and edited main.py:

nano main.py

I followed that up with the following code, which defines the API functionality:

`from fastapi import FastAPI, Query, HTTPException, Request
from fastapi.responses import JSONResponse
import requests
from typing import List
from fastapi.middleware.cors import CORSMiddleware
app = FastAPI()

CORS configuration

origins = [
"http://localhost",
"http://localhost:8080",
"", # Allows requests from any origin (USE WITH CAUTION IN PRODUCTION)
]
app.add_middleware(
CORSMiddleware,
allow_origins=origins,
allow_credentials=True,
allow_methods=[""],
allow_headers=[""],
)
def is_prime(n: int) -> bool:
"""Check if a number is prime."""
if n < 2:
return False
for i in range(2, int(abs(n) * 0.5) + 1):
if n % i == 0:
return False
return True
def is_armstrong(n: int) -> bool:
"""Check if a number is an Armstrong number."""
num_str = str(abs(n))
digits = [int(d) for d in num_str]
power = len(digits)
return sum(d ** power for d in digits) == abs(n)
def digit_sum(n: int) -> int:
"""Calculate the sum of the digits of a number."""
return sum(int(d) for d in str(abs(n)))
def get_fun_fact(n: int) -> str:
"""Fetch a fun fact about a number from the Numbers API."""
try:
response = requests.get(f"http://numbersapi.com/{n}/math")
response.raise_for_status()
return response.text
except requests.exceptions.RequestException:
return "No fun fact available."
@app.exception_handler(ValueError)
async def value_error_handler(request: Request, exc: ValueError):
return JSONResponse(
status_code=400,
content={"number": request.query_params.get("number", ""), "error": True},
)
@app.get("/api/classify-number")
def classify_number(number: str = Query(..., description="Enter a number")):
"""
API endpoint to classify a number.
Accepts numbers in different formats (negative, string, float, etc.).
"""
original_input = number # Store the exact user input
try:
# Convert input to an integer, even if it's a float or string
parsed_number = int(float(number))

except ValueError:
raise ValueError("Invalid input")
is_negative = parsed_number < 0
abs_number = abs(parsed_number)
properties: List[str] = []
is_armstrong_num = is_armstrong(abs_number)
is_odd = abs_number % 2 != 0
if is_armstrong_num and is_odd:
properties = ["armstrong", "odd"]
elif is_armstrong_num and not is_odd:
properties = ["armstrong", "even"]
elif is_odd:
properties = ["odd"]
else:
properties = ["even"]
return {
"number": parsed_number,
"is_prime": is_prime(abs_number),
"is_perfect": False, # No perfect number check in this version
"properties": properties,
"digit_sum": digit_sum(abs_number),
"fun_fact": get_fun_fact(abs_number),
}

Run the app with Uvicorn

if name == "main":
import uvicorn
uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)`

This code processes a number, classifies its properties, and fetches a fun fact.

RUNNING AND TESTING THE API LOCALLY

To start the FastAPI server, I ran the following command:

uvicorn main:app --host 0.0.0.0 --port 8000

I tested the API using a browser by navigating to:

http://127.0.0.1:8000/docs

The test was successful, indicated by the output below:

SETTING UP GITHUB

I initialized a Git repository, committed my files, and pushed them to GitHub:

git init
git add .
git commit -m "Initial commit"
git branch -M main
git remote add origin https://github.com/OmachokoYakubu/HNG-12-DevOps-Projects
git push -u origin main

This ensures my code is version-controlled and publicly available. There was an initial struggle with authentication because GitHub doesn’t accept SSH connections, but I went past that by generating an access token, which resolved the problem.

DEPLOYING THE FASTAPI API ON AWS

Having completed the above configurations, my next step was to deploy the FastAPI on AWS. This required creating an EC2 instance that I named **HNG12 API Server**. I Chose Ubuntu 22.04 LTS (free tier eligible); t3.micro was already set by default for my region, then I used the following network configurations:

Allow inbound traffic for SSH (port 22).
Allow HTTP (port 80) and HTTPS (port 443) for web access.

After launching, the instance was assigned the following IP address:

13.60.180.189

Since SSH access was configured as described above, I proceeded to access the server using the following command:

ssh -i ~/.ssh/HNG-12APIServerKP.pem ubuntu@13.60.180.189

This gave me instant access to the AWS EC2 instance, where I installed the following dependencies:

sudo apt update && sudo apt upgrade -y
sudo apt install python3 python3-pip git curl nginx -y
pip install fastapi uvicorn requests

The commands above effectively enabled Python, pip, git, curl, NGINX and FastAPI in the EC2 instance deployed on AWS.

TRANSFER OF API CODE FROM LOCAL VM TO AWS

In order to transfer the API code from my local VM to AWS, I cloned the GitHub repository previously configured using the following command:

git clone https://github.com/OmachokoYakubu/HNG-12-DevOps-Projects

I navigated in to the repository’s directory to test the functionality of the API on AWS, using the following command:

uvicorn main:app --host 0.0.0.0 --port 8000

It worked perfectly!

CONFIGURING NGINX AS A REVERSE PROXY

Configuring nginx as a reverse proxy required the following crucial steps:

Creating a Configuration File

I navigated to the following directory, and issued the accompanying command as follows:

cd /etc/nginx/sites-available
sudo nano hng12.conf

Afterwards, I inputted the following program:

server { listen 80; server_name 13.60.180.189; # Your public IP or domain name location / { proxy_pass http://127.0.0.1:8000; # Your API's address and port proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header X-Forwarded-Proto $scheme; } }
In order for the NGINX server to run smoothly, I confirmed that the main NGINX configuration files included the configuration file above using the following command:

cat /etc/nginx/nginx.conf

The output of the command above is as follows:

`user www-data;
worker_processes auto;
pid /run/nginx.pid;
include /etc/nginx/modules-enabled/.conf;
events {
worker_connections 768;
# multi_accept on;
}
http {
##
# Basic Settings
##
sendfile on;
tcp_nopush on;
types_hash_max_size 2048;
# server_tokens off;
# server_names_hash_bucket_size 64;
# server_name_in_redirect off;
include /etc/nginx/mime.types;
default_type application/octet-stream;
##
# SSL Settings
##
ssl_protocols TLSv1 TLSv1.1 TLSv1.2 TLSv1.3; # Dropping SSLv3, ref: POODLE
ssl_prefer_server_ciphers on;
##
# Logging Settings
##
access_log /var/log/nginx/access.log;
error_log /var/log/nginx/error.log;
##
# Gzip Settings
##
gzip on;
# gzip_vary on;
# gzip_proxied any;
# gzip_comp_level 6;
# gzip_buffers 16 8k;
# gzip_http_version 1.1;
# gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;
##
# Virtual Host Configs
##
include /etc/nginx/conf.d/.conf;
include /etc/nginx/sites-enabled/hng12.conf; # line 60
}

mail {

# See sample authentication script at:

# http://wiki.nginx.org/ImapAuthenticateWithApachePhpScript

# auth_http localhost/auth.php;

# pop3_capabilities "TOP" "USER";

# imap_capabilities "IMAP4rev1" "UIDPLUS";

server {

listen localhost:110;

protocol pop3;

proxy on;

}

server {

listen localhost:143;

protocol imap;

proxy on;

}

}`

Line 60 above (in italics) includes the configuration file which makes nginx a reverse proxy. The nginx test proved that the configurations above were correct.

TESTING THE LIVE API

To finally determine that the live API is fully functional, I tested it on a browser using the folllowing URL:

http://13.60.180.189/api/classify-number?number=371

It was a resounding success!!!

Further tests with negative integers and non-integers gave unique results:

CREATION OF README.md

The climax of this project was the creation of the README.md file. I navigated into the project directory on the AWS instance, and issued the following command:

nano README.md

I followed that up by pasting the following instructions into the nano text editor:

Number Classification API

This API takes a number as input and returns interesting mathematical properties about it, along with a fun fact.

📌 Features

Checks if the number is Prime
Determines if the number is an Armstrong number
Classifies as Odd or Even
Calculates the Sum of Digits
Retrieves a Fun Fact from the Numbers API

📌 Technologies Used

FastAPI - Python framework for building APIs
Uvicorn - ASGI server to run the FastAPI application
Requests - For fetching data from the Numbers API
Nginx - Reverse proxy for handling HTTP requests

📌 API Endpoints

✅ Classify a Number

URL: GET /api/classify-number?number=<int>
Example: https://13.60.180.189/api/classify-number?number=371
Response (200 OK)


json
  {
    "number": 371,
    "is_prime": false,
    "is_perfect": false,
    "properties": ["armstrong", "odd"],
    "digit_sum": 11,
    "fun_fact": "371 is an Armstrong number because 3^3 + 7^3 + 1^3 = 371"
  }
#Response (400 Bad Request)
{
  "number": "alphabet",
  "error": true
}

#📌 How to Install and Run Locally
#Clone the Repository
git clone https://github.com/OmachokoYakubu/HNG-12-DevOps-Projects.git
cd HNG-12-DevOps-Projects

#Install Dependencies
**pip install fastapi uvicorn requests**

#Run the Server
**uvicorn main:app --host 0.0.0.0 --port 8000**

#Access the API Documentation
Open **http://127.0.0.1:8000/docs** in your browser

#📌 Deployment on AWS
#Launch an EC2 Instance (Ubuntu 22.04 LTS)
#SSH into the instance
**ssh -i ~/.ssh/HNG-12APIServerKP.pem ubuntu@13.60.180.189**

#Clone this repository and install dependencies
#Run Uvicorn to start the API
#Configure Nginx as a reverse proxy
#Access the API using your public IP!#

# Live Deployment
Public API URL: **https://13.60.180.189/api/classify-number?number=371(alternate with different numbers to test output)**

#Author **Omachoko Yakubu**
GitHub: **OmachokoYakubu**


After writing the README.md file, I committed and pushed it to GitHub using the following commands:

**git add README.md
git commit -m "Added README file with API documentation"
git push origin main**

The README.md now provides full API documentation and deployment details

DEPLOYING NGINX ON AWS EC2: MY HNG12 STAGE 0 EXPERIENCE

Omachoko Tanimu Yakubu — Fri, 31 Jan 2025 20:24:50 +0000

INTRODUCTION

As part of the HNG12 internship (under the DevOps track), I was tasked with deploying an NGINX web server on any cloud service of my choice. I chose Amazon Web Services and setup an Ubuntu Server EC2 instance. This involved launching the virtual machine, configuring security rules, and automating the installation of NGINX. In this blog post, I’ll walk you through my experience, the challenges I faced, and my key takeaways.

SETTING UP THE EC2 INSTANCE

Step 1: Launching an Ubuntu Server on AWS

To begin, I created a free tier account and logged into AWS Management Console, then I navigated to EC2. I then clicked "Launch Instance", where I configured the following:

Ubuntu Server 24.04 LTS as the operating system Amazon Machine Image (AMI)

t3.micro instance (Free Tier eligible)

8 GiB of storage (gp3 SSD)

Enabled Auto-assign Public IP so my server could be accessed from the internet

Step 2: Configuring Security Groups

Since the instructions strictly required only HTTP (port 80) access, the following custom security group with the following rule was created:

Inbound Rule:

HTTP (Port 80) → Source: 0.0.0.0/0 (anywhere on the internet).

Outbound Rule:

All traffic allowed (default AWS setting).
I did not enable SSH (port 22) since it was not allowed per the instructions.

AUTOMATING NGINX INSTALLATION

Since SSH access was blocked, I couldn’t manually install NGINX. Instead, I used User Data, a feature that runs commands automatically when an instance is created.

Step 3: Configuring NGINX in User Data

Before launching the instance, I scrolled down to Advanced Details → User Data and pasted the following script:

!/bin/bash

sudo apt update -y
sudo apt install nginx -y echo 'Welcome to DevOps Stage 0 - Omachoko Yakubu/ChockqOteewy' | sudo tee /var/www/html/index.html
sudo systemctl restart nginx

Configuration of NGINX using User Data under Advanced Settings

This script:

Installs NGINX.

Creates an index.html file with a custom message.

Ensures NGINX restarts so the changes take effect.

Details of Instance After Launching

VERIFYING THE DEPLOYMENT

Step 4: Checking the NGINX Web Page

After launching my instance, I copied its Public IPv4 Address from the AWS EC2 Dashboard and visited the public address of my server:

http://13.60.179.5/

Since the setup was successful, the browser displayed the following message:

Welcome to DevOps Stage 0 - Omachoko Yakubu/ChockqOteewy

Success! My NGINX web server was running perfectly.

CHALLENGES AND HOW I OVERCAME THEM

A major challenge I faced while setting up NGINX on an Ubuntu Server in AWS was thinking I needed to connect to the VM manually before running the script. I later discovered that I could input the script directly as part of the initial setup in the Advanced Details section under User Data, which made the process much easier.

KEY TAKEAWAYS

I learned how to deploy and configure NGINX on AWS without SSH access.

I practiced using User Data to automate server setup.

I gained a deeper understanding of AWS EC2 security groups and instance management.

USEFUL RESOURCES

Learn more about DevOps Engineers: https://hng.tech/hire/devops-engineers

Explore AWS Solutions Architects: https://hng.tech/hire/aws-solutions-architects