🐍 Nexus Gateway Python SDK

Sovereign AI Infrastructure for the Modern Edge
One line of code to reduce LLM latency by 95%, costs by 90%, and enforce deterministic governance at the edge.

Key Metrics at a Glance

Why Nexus Gateway?

Real-World Impact

Core Features

Semantic Caching (Layer 0 & 1)

Intelligent hybrid caching with Redis & Pinecone. Get responses in <5ms by eliminating redundant API calls.

Cache Hit: 5ms 
Network Round Trip: 1200ms 
Savings per hit: 100% 

DeepSeek Native Streaming

Full support for OpenAI-compatible reasoning models with Thinking Tokens streaming directly to your terminal.

🔀 Adaptive Universal Router

Single API signature, infinite model combinations:

• Groq — Lightning-fast inference
• Google Gemini — Multimodal powerhouse
• OpenAI — Production reliability
• Anthropic Claude — Reasoning excellence

Automatic failover with self-healing load balancing.

Sovereign Shield (v3.0)

Enterprise-grade governance at the edge:

• ✅ PII redaction before API calls
• ✅ Deterministic data governance
• ✅ AES-256 encryption
• ✅ Audit logging
• ✅ Compliance-ready

💎 Multi-Provider BYOK

Bring Your Own Key to bypass Nexus credits entirely. Use provider billing directly with zero overhead.

Quick Start

1️⃣ Installation

pip install nexus-gateway

2️⃣ Get Your API Key

Head to Nexus Dashboard and grab your provisioned key.

3️⃣ Initialize the Client

from nexus_gateway import NexusClient

client = NexusClient(api_key="nk-your-key-here")

4️⃣ Start Streaming (Your First Call)

# Works with DeepSeek, Groq, Gemini, Claude, GPT-4... 
# Same syntax. Zero friction.

stream = client.chat(
    model="deepseek-r1",
    message="Explain the architecture of a multi-currency reconciliation engine.",
    stream=True
)

for token in stream:
    print(token, end="", flush=True)

Usage Examples

Real-Time Streaming with Auto-Fallback

# Automatic failover if primary model is unavailable
response = client.chat(
    model="gpt-4o",
    message="Analyze this market trend...",
    stream=True,
    fallback_model="claude-3-5-sonnet-latest"  # Automatic pivot
)

for chunk in response:
    print(chunk, end="", flush=True)

BYOK Mode (Zero-Cost Scaling)

# Skip Nexus credits entirely. Use your own provider API keys.

response = client.chat(
    model="gpt-4o",
    message="Summarize legal implications of AI governance.",
    provider_key="sk-your-openai-key",  
    stream=False
)

print(response)

Semantic Caching in Action

# First call: Hits the API, caches the embedding
response1 = client.chat(
    model="llama-3.3-70b",
    message="What is machine learning?",
    cache=True  # Enable semantic caching
)

# Second call: Semantically similar query
# ⚡ Cache hit in 5ms! No API call needed.
response2 = client.chat(
    model="llama-3.3-70b",
    message="Define machine learning for beginners.",
    cache=True
)

Sovereign Shield (Data Privacy)

# Automatic PII redaction before API calls

response = client.chat(
    model="gpt-4o",
    message="My email is john@example.com. Help me with...",
    sovereign_shield=True 
)
# → John's email never leaves your infrastructure

Interactive CLI Tool

Launch the Nexus Sovereign Shell:

nexus

Available Commands

Example Session:

Nexus> /model gpt-4o
✓ Switched to gpt-4o

Nexus> What are the top 3 AI trends in 2025?
[Response streaming...]

Nexus> /key sk-your-openai-key
✓ BYOK credentials loaded. Nexus credits bypassed.

Nexus> /shield on
✓ Sovereign Shield enabled. PII redaction active.

Supported Infrastructure Engines

Deploy across the world's fastest inference providers with zero code changes. Nexus handles routing, failover, and optimization automatically.

Provider Decision Matrix

Speed Champion:        Groq (llama-3.3-70b)          → <100ms
Reasoning Champion:    DeepSeek R1                   → Advanced problem-solving
Vision Champion:       Google Gemini 2.0             → Image/Video understanding
Cost Champion:         OpenAI gpt-4o-mini            → Budget-friendly
Reliability Champion:  OpenAI gpt-4o                 → Enterprise SLA

Authentication & Security

Step 1: Register

Head to Nexus Gateway Dashboard and sign up.

Step 2: Create API Key

Generate a provisioned key (nk-...) from your dashboard.

Step 3: Store Securely

# Set as environment variable (recommended)
export NEXUS_API_KEY="nk-your-key-here"

Step 4: Initialize

from nexus_gateway import NexusClient
import os

client = NexusClient(api_key=os.getenv("NEXUS_API_KEY"))

Security Features

• AES-256 Encryption at rest and in transit
• PII Redaction before provider APIs
• Audit Logging for compliance
• BYOK Support for zero trust architectures
• Key Rotation friendly

Performance Benchmarks

Latency Comparison

Nexus Gateway (Cache Hit):        5ms    ████░░░░░░░░░░░░░░░░░░
OpenAI SDK (Network):          1200ms    ████████████████████████
Improvement:                   99.6%    

Cost Reduction

Standard Provider Calls:        $0.001/call
Nexus Cached Calls:            $0.000/call  (after first hit)
Annual Savings (10M calls):    $10,000     

🎓 Documentation & Resources

Community & Support

• Email Support: support@nexus-gateway.org

📄 License & Attribution

Licensed under the MIT License — free for commercial and personal use.

© 2025 Sunny Anand
Mission Control · Docs · GitHub

Getting Started Right Now

# 3 lines to production
from nexus_gateway import NexusClient
client = NexusClient(api_key="nk-your-key")
print(client.chat(model="gpt-4o", message="Hello, Nexus!"))

Ready to reduce latency by 95%? Get your API key →