ObjectiveAI API Server

Score everything. Rank everything. Simulate anyone.

A self-hostable API server for ObjectiveAI - run the full ObjectiveAI platform locally or use the library to build your own custom server.

Website | API | GitHub | Discord

Overview

This crate provides two ways to use the ObjectiveAI API:

1. Run the server - Start a local instance of the ObjectiveAI API
2. Import as a library - Build your own server with custom authentication, routing, or middleware

Running Locally

Prerequisites

• Rust (latest stable)
• An OpenRouter API key (for LLM access)
• Optionally, an ObjectiveAI API key (for Profile Computation)

Quick Start

# Clone the repository
git clone https://github.com/ObjectiveAI/objectiveai
cd objectiveai/objectiveai-api

# Create a .env file
cat > .env << EOF
OPENROUTER_API_KEY=sk-or-...
OBJECTIVEAI_API_KEY=oai-...  # Optional
EOF

# Run the server
cargo run --release

The server starts on http://localhost:5000 by default.

Environment Variables

Backoff Configuration

Using as a Library

Add to your Cargo.toml:

[dependencies]
objectiveai-api = "0.1.0"

Example: Custom Server

use objectiveai_api::{chat, ctx, vector, functions, ensemble, ensemble_llm};
use std::sync::Arc;

// Create your HTTP client
let http_client = reqwest::Client::new();

// Create the ObjectiveAI HTTP client
let objectiveai_client = Arc::new(objectiveai::HttpClient::new(
    http_client.clone(),
    Some("https://api.objective-ai.io".to_string()),
    Some("apk...".to_string()),
    None, None, None,
));

// Build the component stack
let ensemble_llm_fetcher = Arc::new(
    ensemble_llm::fetcher::CachingFetcher::new(Arc::new(
        ensemble_llm::fetcher::ObjectiveAiFetcher::new(objectiveai_client.clone()),
    )),
);

let chat_client = Arc::new(chat::completions::Client::new(
    ensemble_llm_fetcher.clone(),
    Arc::new(chat::completions::usage_handler::LogUsageHandler),
    // ... upstream client configuration
));

// Use in your own Axum/Actix/Warp routes

Architecture

Modules

Component Stack

Request
    │
    ▼
┌─────────────────────────────────────────────────┐
│  Functions Client                               │
│  - Executes Function pipelines                  │
│  - Handles Profile weights                      │
└─────────────────────────────────────────────────┘
    │
    ▼
┌─────────────────────────────────────────────────┐
│  Vector Completions Client                      │
│  - Runs ensemble voting                         │
│  - Combines votes into scores                   │
└─────────────────────────────────────────────────┘
    │
    ▼
┌─────────────────────────────────────────────────┐
│  Chat Completions Client                        │
│  - Sends prompts to individual LLMs             │
│  - Handles retries and backoff                  │
└─────────────────────────────────────────────────┘
    │
    ▼
┌─────────────────────────────────────────────────┐
│  Upstream Client (OpenRouter)                   │
│  - Actual LLM API calls                         │
└─────────────────────────────────────────────────┘

Customization Points

Each layer uses traits for dependency injection:

• Fetchers - Implement custom caching or data sources for Ensembles, Functions, Profiles
• Usage Handlers - Track usage, billing, or analytics
• Context Extensions - Add per-request state (authentication, BYOK keys, etc.)

API Endpoints

Chat Completions

• POST /chat/completions - Create chat completion

Vector Completions

• POST /vector/completions - Create vector completion
• POST /vector/completions/{id} - Get completion votes
• POST /vector/completions/cache - Get cached vote

Functions

• GET /functions - List functions
• GET /functions/{owner}/{repo} - Get function
• POST /functions/{owner}/{repo} - Execute remote function with inline profile

Profiles

• GET /functions/profiles - List profiles
• GET /functions/profiles/{owner}/{repo} - Get profile
• POST /functions/{owner}/{repo}/profiles/{owner}/{repo} - Execute remote function with remote profile
• POST /functions/profiles/compute - Train a profile

Ensembles

• GET /ensembles - List ensembles
• GET /ensembles/{id} - Get ensemble

License

MIT