Drop-in replacement for OpenAI. Supports reasoning_effort="high", multi-turn memory, and real-time streaming.

from openai import OpenAI

# 1. Point client to your local gateway
client = OpenAI(
    base_url="http://127.0.0.1:8888/v1",
    api_key="sk-gemini-YOUR_KEY_HERE"  # Created in API Keys tab
)

# 2. Call with reasoning & project memory
response = client.chat.completions.create(
    model="gemini-3.8-flash",
    reasoning_effort="high",  # "off", "low", "medium", "high"
    messages=[
        {"role": "system", "content": "You are a lead cloud architect."},
        {"role": "user", "content": "We need to scale our microservices to 100k RPS."},
        {"role": "assistant", "content": "I recommend a partitioned Kafka event bus with Redis read-through cache."},
        {"role": "user", "content": "How do we handle database write failover in this design?"}
    ],
    stream=True
)

# 3. Real-time streaming output
for chunk in response:
    content = chunk.choices[0].delta.content
    if content:
        print(content, end="", flush=True)
print()

Works with npm i openai in Express, Fastify, NestJS, and Node scripts.

import OpenAI from 'openai';

const openai = new OpenAI({
  baseURL: 'http://127.0.0.1:8888/v1',
  apiKey: 'sk-gemini-YOUR_KEY_HERE',
});

async function main() {
  const stream = await openai.chat.completions.create({
    model: 'gemini-3.7-pro',
    reasoning_effort: 'medium',
    messages: [
      { role: 'system', content: 'You are an elite TypeScript developer.' },
      { role: 'user', content: 'Write a zero-dependency LRU cache class with TTL support.' }
    ],
    stream: true,
  });

  for await (const chunk of stream) {
    process.stdout.write(chunk.choices[0]?.delta?.content || '');
  }
}

main();

Direct real-time SSE stream reader in browser without external dependencies.

async function streamFromGemini(userPrompt, onToken) {
  const response = await fetch('http://127.0.0.1:8888/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer sk-gemini-YOUR_KEY_HERE'
    },
    body: JSON.stringify({
      model: 'gemini-3.8-flash',
      reasoning_effort: 'high',
      messages: [{ role: 'user', content: userPrompt }],
      stream: true
    })
  });

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

  while (true) {
    const { value, done } = await reader.read();
    if (done) break;
    buffer += decoder.decode(value, { stream: true });
    const lines = buffer.split('\n');
    buffer = lines.pop();

    for (const line of lines) {
      if (!line.startsWith('data: ')) continue;
      const dataStr = line.slice(6).trim();
      if (dataStr === '[DONE]') return;
      try {
        const chunk = JSON.parse(dataStr);
        const text = chunk.choices[0]?.delta?.content || '';
        if (text) onToken(text);
      } catch (e) {}
    }
  }
}

Pure Go standard library (net/http + bufio) with real-time SSE streaming, reasoning effort, and project memory.

package main

import (
	"bufio"
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"strings"
)

type ChatMessage struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}

type ChatRequest struct {
	Model           string        `json:"model"`
	Messages        []ChatMessage `json:"messages"`
	ReasoningEffort string        `json:"reasoning_effort,omitempty"`
	Stream          bool          `json:"stream"`
}

type StreamChunk struct {
	Choices []struct {
		Delta struct {
			Content string `json:"content"`
		} `json:"delta"`
	} `json:"choices"`
}

func main() {
	reqBody := ChatRequest{
		Model:           "gemini-3.8-flash",
		ReasoningEffort: "high", // "off", "low", "medium", "high"
		Stream:          true,
		Messages: []ChatMessage{
			{Role: "system", Content: "You are a lead Go backend architect."},
			{Role: "user", Content: "Build a high-concurrency worker pool in Go."},
		},
	}

	payload, _ := json.Marshal(reqBody)
	req, _ := http.NewRequest("POST", "http://127.0.0.1:8888/v1/chat/completions", bytes.NewReader(payload))
	req.Header.Set("Authorization", "Bearer sk-gemini-YOUR_KEY_HERE")
	req.Header.Set("Content-Type", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	reader := bufio.NewReader(resp.Body)
	for {
		line, err := reader.ReadString('\n')
		if err != nil {
			break
		}
		line = strings.TrimSpace(line)
		if strings.HasPrefix(line, "data: ") {
			data := strings.TrimPrefix(line, "data: ")
			if data == "[DONE]" {
				break
			}
			var chunk StreamChunk
			if json.Unmarshal([]byte(data), &chunk) == nil && len(chunk.Choices) > 0 {
				fmt.Print(chunk.Choices[0].Delta.Content)
			}
		}
	}
	fmt.Println()
}

Upload images/PDFs and stream answers natively via /api/v1/generate.

# Step 1: Upload Image or PDF (Optional)
UPLOAD_RES=$(curl -s -X POST http://127.0.0.1:8888/api/v1/upload \
  -F "file=@document.pdf")
FILE_PATH=$(echo $UPLOAD_RES | jq -r .file_path)

# Step 2: Stream Multimodal Analysis in Real-Time
curl -N -X POST http://127.0.0.1:8888/api/v1/generate \
  -H "Authorization: Bearer sk-gemini-YOUR_KEY_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.8-flash",
    "prompt": "Extract all financial tables and summarize insights.",
    "files": ["'$FILE_PATH'"],
    "reasoning": "high",
    "stream": true
  }'