Your App (Python / JS / Java / C++)
    ↕  HTTP  (port 9999)

Offline Intelligence Rust Server
↕ HTTP (port 8081)
llama-server (llama.cpp)
↕
GGUF model file (local)

Windows: C:llamallama-server.exe
macOS/Linux: /usr/local/bin/llama-server

LLAMA_BIN=/usr/local/bin/llama-server
MODEL_PATH=/home/yourname/.offline-intelligence/models/llama-3.2-3b-instruct-q4_k_m.gguf
API_HOST=127.0.0.1
API_PORT=9999

LLAMA_BIN=C:llamallama-server.exe
MODEL_PATH=C:modelsllama-3.2-3b-instruct-q4_k_m.gguf
API_HOST=127.0.0.1
API_PORT=9999

cargo install offline-intelligence
offline-intelligence

Starting with thread-based architecture
Memory database initialized
Model manager initialized successfully
Starting server on 127.0.0.1:9999

curl http://127.0.0.1:9999/healthz

pip install offline-intelligence==0.1.5
npm install offline-intelligence@0.1.5
cargo add offline-intelligence@0.1.5

cargo add offline-intelligence@0.1.5

pip install offline-intelligence==0.1.5

npm install offline-intelligence@0.1.5

<repositories>
    <repository>
        <id>jitpack.io</id>
        <url>https://jitpack.io</url>
    </repository>
</repositories>
<dependency>
    <groupId>com.github.OfflineIntelligence</groupId>
    <artifactId>offline-intelligence</artifactId>
    <version>v0.1.5</version>
</dependency>

repositories { maven { url 'https://jitpack.io' } }
dependencies { 
    implementation 'com.github.OfflineIntelligence:offline-intelligence:v0.1.5' 
}

include(FetchContent)
FetchContent_Declare(
    offline_intelligence
    GIT_REPOSITORY https://github.com/OfflineIntelligence/offline-intelligence.git
    GIT_TAG        v0.1.5
    GIT_SHALLOW    TRUE
)
FetchContent_MakeAvailable(offline_intelligence)
target_link_libraries(your_target PRIVATE offline_intelligence)

conan install --requires="offline-intelligence/0.1.5" --build=missing

use offline_intelligence::{config::Config, run_thread_server};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let cfg = Config::from_env()?;
    run_thread_server(cfg, None).await
}

use offline_intelligence::{config::Config, run_thread_server};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let mut cfg = Config::from_env()?;
    cfg.api_host  = "0.0.0.0".to_string();
    cfg.api_port  = 9999;
    cfg.model_path = "/path/to/model.gguf".to_string();
    cfg.gpu_layers = 35;
    run_thread_server(cfg, None).await
}

from offline_intelligence import OfflineIntelligence, Config
import requests

cfg = Config.from_env()
ai  = OfflineIntelligence(cfg)

print(ai.health_check())

response = ai.generate("Explain quantum computing in simple terms")
print(response)

for chunk in ai.generate_stream("Write a short poem about the ocean"):
    print(chunk, end="", flush=True)

convs = ai.get_conversations()
title = ai.generate_title(session_id="abc123", first_message="Tell me about space")

stats = ai.get_memory_stats("abc123")
ai.optimize_memory()

# Tools, mode switching, API keys, feedback
settings = requests.get("http://127.0.0.1:9999/tools/settings").json()
requests.post("http://127.0.0.1:9999/mode", json={"mode": "online"})
requests.post("http://127.0.0.1:9999/api-keys", json={"key_type": "openrouter", "value": "sk-or-..."})
requests.post("http://127.0.0.1:9999/feedback", json={"message": "Great!"})

from offline_intelligence import Config, OfflineIntelligence

cfg = Config()
cfg.api_host        = "127.0.0.1"
cfg.api_port        = 9999
cfg.backend_url     = "http://127.0.0.1:8081"
cfg.openrouter_api_key = "sk-or-..."

ai = OfflineIntelligence(cfg)

const { OfflineIntelligence, Config } = require('offline-intelligence');

const cfg = Config.fromEnv();
const ai  = new OfflineIntelligence(cfg);

async function main() {
    const health = await ai.healthCheck();
    console.log(health);

    const response = await ai.generate('What is machine learning?');
    console.log(response);

    await ai.generateStream('Tell me a story', chunk => process.stdout.write(chunk));

    const convs = await ai.getConversations();
    const title = await ai.generateTitle('abc123', 'Tell me about black holes');

    const stats = await ai.getMemoryStats('abc123');
    await ai.optimizeMemory();
}

main();

import com.offlineintelligence.OfflineIntelligence;
import com.offlineintelligence.Config;

public class Main {
    public static void main(String[] args) {
        Config cfg = Config.fromEnv();
        OfflineIntelligence ai = new OfflineIntelligence(cfg);

        System.out.println(ai.healthCheck());

        String response = ai.generate("Explain recursion");
        System.out.println(response);

        ai.generateStream("Write a haiku", chunk -> System.out.print(chunk));

        List<Conversation> convs = ai.getConversations();
        String title = ai.generateTitle("abc123", "Space exploration");

        MemoryStats stats = ai.getMemoryStats("abc123");
        ai.optimizeMemory();
    }
}

#include <offline_intelligence/offline_intelligence.hpp>
#include <iostream>

int main() {
    auto cfg = offline_intelligence::Config::from_env();
    auto ai  = offline_intelligence::OfflineIntelligence(cfg);

    std::cout << ai.health_check() << std::endl;

    auto response = ai.generate("What is AI?");
    std::cout << response << std::endl;

    ai.generate_stream("Count to 10", [](const std::string& chunk) {
        std::cout << chunk << std::flush;
    });

    auto convs = ai.get_conversations();
    auto title = ai.generate_title("abc123", "Programming help");

    auto stats = ai.get_memory_stats("abc123");
    ai.optimize_memory();

    return 0;
}

GET  http://127.0.0.1:9999/tools/settings
POST http://127.0.0.1:9999/tools/settings   {"enabled": true, "brave_key": "optional"}

POST /auth/register   {"username": "alice", "email": "alice@example.com", "password": "secret"}
POST /auth/login      {"email": "alice@example.com", "password": "secret"}
GET  /auth/google?redirect_uri=http://localhost:3000/callback
GET  /auth/verify?token=<email-verification-token>

POST   /api-keys   {"key_type": "huggingface", "value": "hf_..."}
POST   /api-keys   {"key_type": "openrouter",  "value": "sk-or-..."}
GET    /api-keys?key_type=huggingface
DELETE /api-keys?key_type=openrouter

POST /mode   {"mode": "offline"}
POST /mode   {"mode": "online"}

POST /feedback   {"message": "Really helpful!", "email": "optional@email.com"}

# Required (no auto-detection)

LLAMA_BIN=/usr/local/bin/llama-server
MODEL_PATH=/home/user/.offline-intelligence/models/model.q4_k_m.gguf

Server (defaults shown)
API_HOST=127.0.0.1
API_PORT=9999
LLAMA_HOST=127.0.0.1
LLAMA_PORT=8081
PROMETHEUS_PORT=9000

Backend and cloud fallback
BACKEND_URL=http://127.0.0.1:8081
OPENROUTER_API_KEY=sk-or-... # optional, only for online mode

Performance: auto-detected if omitted
CTX_SIZE=8192
BATCH_SIZE=256
GPU_LAYERS=auto
THREADS=auto
Rate limiting and concurrency
MAX_CONCURRENT_STREAMS=4
REQUESTS_PER_SECOND=24

# Health and readiness

curl http://127.0.0.1:9999/healthz
curl http://127.0.0.1:9999/readyz

Prometheus metrics (note: separate port 9000)
curl http://127.0.0.1:9000/metrics

Admin status
curl http://127.0.0.1:9999/admin/status

Memory stats for a session
curl http://127.0.0.1:9999/memory/stats/my-session-id