API Reference

http://localhost:8000

https://apollo.onyxlab.ai

{
  "status": "healthy",
  "version": "4.1.0",
  "gpu_enabled": true,
  "gpu_count": 1,
  "gpu_name": "NVIDIA RTX 4090",
  "vector_store": "chroma",
  "document_count": 142589,
  "cache_enabled": true,
  "conversation_memory_enabled": true
}

curl http://localhost:8000/health

{
  "question": "Can I grow a beard?",
  "mode": "simple",
  "use_context": false,
  "rerank_preset": "balanced"
}

{
  "question": "What are the fitness standards?",
  "mode": "simple"
}

{
  "question": "Compare beard policies across different regulations",
  "mode": "adaptive"
}

{
  "answer": "According to AFI 36-2903, Air Force members are generally prohibited from growing beards except for approved medical or religious accommodations...",
  "sources": [
    {
      "content": "3.1.2. Beards. Beards are not authorized except for...",
      "metadata": {
        "source": "AFI_36-2903_Dress_and_Appearance.pdf",
        "page": 12,
        "chunk_id": "chunk_1234"
      },
      "relevance_score": 0.9234
    }
  ],
  "metadata": {
    "processing_time_ms": 12456,
    "mode": "simple",
    "cache_hit": false,
    "query_type": "simple",
    "strategy": "vector_search",
    "retrieved_chunks": 7,
    "model": "llama3.1:8b",
    "gpu_accelerated": true
  },
  "explanation": null
}

curl -X POST http://localhost:8000/api/query \
  -H "Content-Type: application/json" \
  -d '{
    "question": "Can I grow a beard?",
    "mode": "simple",
    "use_context": false
  }'

import requests
 
response = requests.post(
    "http://localhost:8000/api/query",
    json={
        "question": "Can I grow a beard?",
        "mode": "simple",
        "use_context": False,
        "rerank_preset": "balanced"
    }
)
 
if response.status_code == 200:
    result = response.json()
    print(f"Answer: {result['answer']}")
    print(f"\nSources ({len(result['sources'])}):")
    for i, source in enumerate(result['sources'], 1):
        print(f"{i}. {source['metadata']['source']} (score: {source['relevance_score']:.3f})")
    print(f"\nProcessing time: {result['metadata']['processing_time_ms']}ms")
    print(f"GPU accelerated: {result['metadata']['gpu_accelerated']}")
else:
    print(f"Error: {response.status_code} - {response.text}")

interface QueryResponse {
  answer: string;
  sources: Array<{
    content: string;
    metadata: {
      source: string;
      page?: number;
      chunk_id: string;
    };
    relevance_score: number;
  }>;
  metadata: {
    processing_time_ms: number;
    mode: string;
    cache_hit: boolean;
    gpu_accelerated: boolean;
  };
}
 
async function queryApollo(question: string): Promise<QueryResponse> {
  const response = await fetch('http://localhost:8000/api/query', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      question,
      mode: 'simple',
      use_context: false
    })
  });
 
  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  }
 
  return response.json();
}
 
// Usage
const result = await queryApollo("Can I grow a beard?");
console.log(`Answer: ${result.answer}`);
console.log(`Processing time: ${result.metadata.processing_time_ms}ms`);

{
  "detail": "Query cannot be empty or whitespace-only"
}

data: {"type":"token","content":"The"}
data: {"type":"token","content":" Air"}
data: {"type":"token","content":" Force"}
...
data: {"type":"sources","content":[...]}
data: {"type":"metadata","content":{...}}
data: {"type":"done"}

curl -N -X POST http://localhost:8000/api/query/stream \
  -H "Content-Type: application/json" \
  -d '{
    "question": "Explain the chain of command",
    "mode": "simple"
  }'

const eventSource = new EventSource(
  'http://localhost:8000/api/query/stream?' + new URLSearchParams({
    question: 'Explain the chain of command',
    mode: 'simple'
  })
);
 
eventSource.onmessage = (event) => {
  const data = JSON.parse(event.data);
 
  switch (data.type) {
    case 'token':
      process.stdout.write(data.content);  // Stream text as it arrives
      break;
    case 'sources':
      console.log('\n\nSources:', data.content);
      break;
    case 'metadata':
      console.log('Metadata:', data.content);
      break;
    case 'done':
      eventSource.close();
      console.log('\n\nGeneration complete');
      break;
    case 'error':
      console.error('Error:', data.content);
      eventSource.close();
      break;
  }
};

import requests
import json
 
response = requests.post(
    'http://localhost:8000/api/query/stream',
    json={
        'question': 'Explain the chain of command',
        'mode': 'simple'
    },
    stream=True  # Enable streaming
)
 
for line in response.iter_lines():
    if line:
        # SSE format: "data: {json}\n\n"
        if line.startswith(b'data: '):
            event = json.loads(line[6:])  # Skip "data: " prefix
 
            if event['type'] == 'token':
                print(event['content'], end='', flush=True)
            elif event['type'] == 'sources':
                print(f"\n\nSources: {len(event['content'])} documents")
            elif event['type'] == 'metadata':
                print(f"\nProcessing time: {event['content']['processing_time_ms']}ms")
            elif event['type'] == 'done':
                print("\n\nComplete")
                break

{
  "success": true,
  "message": "Conversation memory cleared successfully"
}

curl -X POST http://localhost:8000/api/conversation/clear

import requests
 
response = requests.post('http://localhost:8000/api/conversation/clear')
result = response.json()
print(result['message'])

X-RateLimit-Limit: 30
X-RateLimit-Remaining: 25
X-RateLimit-Reset: 1640995200

environment:
  - CORS_ORIGINS=https://yourdomain.com,https://app.yourdomain.com

{
  "metadata": {
    "processing_time_ms": 124,  // <-- 100x faster!
    "cache_hit": true,
    "cached_at": "2025-01-15T10:30:00Z"
  }
}

import requests
 
BASE_URL = "http://localhost:8000"
 
# Start conversation with context
response1 = requests.post(
    f"{BASE_URL}/api/query",
    json={
        "question": "What are the beard grooming standards?",
        "mode": "simple",
        "use_context": True  # Enable context
    }
)
print(response1.json()['answer'])
 
# Follow-up question (references previous context)
response2 = requests.post(
    f"{BASE_URL}/api/query",
    json={
        "question": "What about mustaches?",  # Implicit reference
        "mode": "simple",
        "use_context": True  # Use previous context
    }
)
print(response2.json()['answer'])
 
# Clear when switching topics
requests.post(f"{BASE_URL}/api/conversation/clear")

questions = [
    "Can I grow a beard?",
    "What are the fitness standards?",
    "Explain the chain of command"
]
 
results = []
for question in questions:
    response = requests.post(
        "http://localhost:8000/api/query",
        json={"question": question, "mode": "simple"}
    )
    results.append(response.json())
 
# Process results
for i, result in enumerate(results):
    print(f"\nQ{i+1}: {questions[i]}")
    print(f"A: {result['answer'][:200]}...")
    print(f"Time: {result['metadata']['processing_time_ms']}ms")

import requests
from requests.exceptions import RequestException
 
def query_apollo_safe(question: str, mode: str = "simple"):
    try:
        response = requests.post(
            "http://localhost:8000/api/query",
            json={"question": question, "mode": mode},
            timeout=120  # 2 minute timeout
        )
        response.raise_for_status()
        return response.json()
 
    except requests.exceptions.Timeout:
        print("Error: Request timed out after 2 minutes")
        return None
 
    except requests.exceptions.HTTPError as e:
        if e.response.status_code == 429:
            print("Error: Rate limit exceeded. Wait before retrying.")
        elif e.response.status_code == 503:
            print("Error: Service unavailable. System may be starting up.")
        else:
            print(f"HTTP Error {e.response.status_code}: {e.response.text}")
        return None
 
    except RequestException as e:
        print(f"Network error: {e}")
        return None
 
# Usage
result = query_apollo_safe("Can I grow a beard?")
if result:
    print(result['answer'])