Captain API

1
import requests
2
3
# Configuration
4
API_KEY = "cap_prod_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
5
ORG_ID = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
6
7
headers = {
8
    "Authorization": f"Bearer {API_KEY}",
9
    "X-Organization-ID": ORG_ID
10
}
11
12
response = requests.post(
13
    "https://api.runcaptain.com/v1/responses",
14
    headers=headers,
15
    data={
16
        'input': 'Large text content...',
17
        'query': 'What are the main themes?',
18
        'stream': 'true'
19
    },
20
    stream=True  # Important: Enable streaming in requests library
21
)
22
23
# Process streamed chunks
24
for line in response.iter_lines():
25
    if line:
26
        line_text = line.decode('utf-8')
27
        if line_text.startswith('data: '):
28
            data = line_text[6:]  # Remove 'data: ' prefix
29
            print(data, end='', flush=True)

1
import requests
2
3
# Configuration
4
API_KEY = "cap_prod_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
5
ORG_ID = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
6
BASE_URL = "https://api.runcaptain.com"
7
8
headers = {
9
    "Authorization": f"Bearer {API_KEY}",
10
    "X-Organization-ID": ORG_ID
11
}
12
13
# Non-streaming request
14
response = requests.post(
15
    f"{BASE_URL}/v1/responses",
16
    headers=headers,
17
    data={
18
        'input': 'Your large document text here...',
19
        'query': 'What are the main themes?'
20
    }
21
)
22
23
result = response.json()
24
print(result['response'])

1
response = requests.post(
2
    f"{BASE_URL}/v1/responses",
3
    headers=headers,
4
    data={
5
        'input': 'Your large document text here...',
6
        'query': 'What are the main themes?',
7
        'stream': 'true'
8
    },
9
    stream=True  # Important: Enable streaming in requests
10
)
11
12
for line in response.iter_lines():
13
    if line:
14
        line_text = line.decode('utf-8')
15
        if line_text.startswith('data: '):
16
            data = line_text[6:]  # Remove 'data: ' prefix
17
            print(data, end='', flush=True)

1
#!/usr/bin/env python3
2
"""
3
Captain OpenAI-Compatible Client - Recommended Approach
4
"""
5
from openai import OpenAI
6
7
# Configuration
8
BASE_URL = "https://api.runcaptain.com/v1"
9
API_KEY = "cap_prod_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
10
ORG_ID = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
11
12
# Initialize OpenAI client pointing to Captain
13
client = OpenAI(
14
    base_url=BASE_URL,
15
    api_key=API_KEY,
16
    default_headers={
17
        "X-Organization-ID": ORG_ID
18
    }
19
)
20
21
# Load your large document
22
print("Loading text file...")
23
with open("large_document.txt", "r") as f:
24
    context = f.read()
25
26
print(f"Loaded {len(context):,} characters")
27
print("-" * 50)
28
29
# Captain approach: instructions in messages, context in extra_body
30
response = client.chat.completions.create(
31
    model="captain-voyager-latest",
32
    messages=[
33
        {"role": "system", "content": "You are a helpful assistant specialized in document analysis."},
34
        {"role": "user", "content": "What are the main themes in this document?"}
35
    ],
36
    stream=True,
37
    temperature=0.7,
38
    extra_body={
39
        "captain": {
40
            "context": context  # Large context goes here
41
        }
42
    }
43
)
44
45
# Stream the response
46
print("Response: ", end="", flush=True)
47
for chunk in response:
48
    if chunk.choices[0].delta.content:
49
        print(chunk.choices[0].delta.content, end="", flush=True)
50
51
print("
52
" + "-" * 50)
53
print("Done!")

1
#!/usr/bin/env python3
2
"""
3
Captain File Upload for Very Large Contexts (>10MB)
4
"""
5
import json
6
import requests
7
8
# Configuration
9
BASE_URL = "https://api.runcaptain.com/v1"
10
API_KEY = "cap_prod_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
11
ORG_ID = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
12
13
# Load large file
14
with open("very_large_file.txt", "r", encoding="utf-8") as f:
15
    context = f.read()
16
17
context_size = len(context.encode('utf-8'))
18
print(f"Uploading {context_size:,} bytes via multipart...")
19
20
# Prepare multipart form data
21
url = f"{BASE_URL}/chat/completions/upload"
22
headers = {
23
    "Authorization": f"Bearer {API_KEY}",
24
    "X-Organization-ID": ORG_ID
25
}
26
27
files = {
28
    'file': ('context.txt', context.encode('utf-8'), 'text/plain')
29
}
30
31
data = {
32
    'messages': json.dumps([
33
        {"role": "user", "content": "What are the main themes?"}
34
    ]),
35
    'model': 'captain-voyager-latest',
36
    'stream': 'true',
37
    'temperature': '0.7'
38
}
39
40
# Make streaming request
41
response = requests.post(url, headers=headers, files=files, data=data, stream=True)
42
43
# Parse SSE stream
44
print("Response: ", end="", flush=True)
45
for line in response.iter_lines():
46
    if line:
47
        line = line.decode('utf-8')
48
        if line.startswith('data: '):
49
            data_str = line[6:]
50
            if data_str == '[DONE]':
51
                break
52
            try:
53
                chunk_data = json.loads(data_str)
54
                if 'choices' in chunk_data:
55
                    delta = chunk_data['choices'][0].get('delta', {})
56
                    if 'content' in delta and delta['content']:
57
                        print(delta['content'], end="", flush=True)
58
            except json.JSONDecodeError:
59
                pass
60
61
print("\n" + "-" * 50)
62
print("Done!")

1
response = client.chat.completions.create(
2
    model="captain-voyager-latest",
3
    messages=[
4
        {"role": "system", "content": "You are Dr. Watson, a medical expert specializing in research analysis"},
5
        {"role": "user", "content": "What are the key findings?"}
6
    ],
7
    extra_body={
8
        "captain": {
9
            "context": medical_research_papers  # Large document(s)
10
        }
11
    }
12
)
13
# AI responds as Dr. Watson with your custom medical expertise

1
response = client.chat.completions.create(
2
    model="captain-voyager-latest",
3
    messages=[
4
        {"role": "user", "content": "What are the key findings?"}
5
    ],
6
    extra_body={
7
        "captain": {
8
            "context": medical_research_papers  # Large document(s)
9
        }
10
    }
11
)
12
# AI responds with Captain's default helpful, informative persona

1
#!/usr/bin/env python3
2
"""
3
Captain HTTP API - Multipart File Upload for Large Contexts
4
"""
5
import json
6
import requests
7
8
# Configuration
9
BASE_URL = "https://api.runcaptain.com/v1"
10
API_KEY = "cap_prod_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
11
ORG_ID = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
12
13
# Load large text file (can be 100MB+)
14
print("Loading text file...")
15
file_path = "large_document.txt"
16
with open(file_path, "r", encoding="utf-8") as f:
17
    context = f.read()
18
19
context_size = len(context.encode('utf-8'))
20
print(f"Loaded {len(context):,} characters ({context_size:,} bytes)")
21
print("-" * 50)
22
23
# Prepare request
24
url = f"{BASE_URL}/chat/completions/upload"
25
headers = {
26
    "Authorization": f"Bearer {API_KEY}",
27
    "X-Organization-ID": ORG_ID
28
}
29
30
messages = [
31
    {
32
        "role": "user",
33
        "content": "What are the main themes in this corpus?",
34
    }
35
]
36
37
# Prepare multipart form data
38
files = {
39
    'file': ('context.txt', context.encode('utf-8'), 'text/plain')
40
}
41
42
data = {
43
    'messages': json.dumps(messages),
44
    'model': 'captain-voyager-latest',
45
    'stream': 'true',  # Enable streaming
46
    'temperature': '0.7'
47
}
48
49
print(f"Uploading {context_size:,} bytes via multipart...")
50
51
# Make streaming request
52
response = requests.post(url, headers=headers, files=files, data=data, stream=True)
53
54
if response.status_code != 200:
55
    print(f"Error: {response.status_code}")
56
    print(response.text)
57
    exit(1)
58
59
print("Response: ", end="", flush=True)
60
61
# Parse SSE stream (OpenAI format)
62
for line in response.iter_lines():
63
    if line:
64
        line = line.decode('utf-8')
65
        if line.startswith('data: '):
66
            data_str = line[6:]  # Remove 'data: ' prefix
67
            if data_str == '[DONE]':
68
                break
69
            try:
70
                chunk_data = json.loads(data_str)
71
                if 'choices' in chunk_data and len(chunk_data['choices']) > 0:
72
                    delta = chunk_data['choices'][0].get('delta', {})
73
                    if 'content' in delta and delta['content']:
74
                        print(delta['content'], end="", flush=True)
75
            except json.JSONDecodeError:
76
                pass
77
78
print("\n" + "-" * 50)
79
print("Done!")

1
from openai import OpenAI
2
3
client = OpenAI(
4
    base_url="https://api.runcaptain.com/v1",
5
    api_key="YOUR_API_KEY",
6
    default_headers={"X-Organization-ID": "YOUR_ORG_ID"}
7
)
8
9
# Define tools
10
tools = [
11
    {
12
        "type": "function",
13
        "function": {
14
            "name": "calculate",
15
            "description": "Perform basic arithmetic operations",
16
            "parameters": {
17
                "type": "object",
18
                "properties": {
19
                    "operation": {
20
                        "type": "string",
21
                        "enum": ["add", "subtract", "multiply", "divide"]
22
                    },
23
                    "a": {"type": "number"},
24
                    "b": {"type": "number"}
25
                },
26
                "required": ["operation", "a", "b"]
27
            },
28
            "strict": True  # Required for Captain/Cerebras
29
        }
30
    }
31
]
32
33
# Make request with tools
34
response = client.chat.completions.create(
35
    model="captain-voyager-latest",
36
    messages=[
37
        {"role": "system", "content": "Q1 Revenue: $125,000\nQ2 Revenue: $150,000"},
38
        {"role": "user", "content": "What's the total revenue for Q1 and Q2?"}
39
    ],
40
    tools=tools,
41
    stream=True
42
)
43
44
for chunk in response:
45
    if chunk.choices[0].delta.content:
46
        print(chunk.choices[0].delta.content, end="", flush=True)

1
{
2
    "type": "function",
3
    "function": {
4
        "name": "tool_name",           # Function name (alphanumeric + underscores)
5
        "description": "What it does",  # Clear description for the LLM
6
        "parameters": {                 # JSON Schema for parameters
7
            "type": "object",
8
            "properties": {
9
                "param_name": {
10
                    "type": "string|number|boolean|array|object",
11
                    "description": "Parameter description"
12
                }
13
            },
14
            "required": ["param_name"]
15
        },
16
        "strict": True  # REQUIRED
17
}

1
from openai import OpenAI
2
3
client = OpenAI(
4
    base_url="https://api.runcaptain.com/v1",
5
    api_key="YOUR_API_KEY",
6
    default_headers={"X-Organization-ID": "YOUR_ORG_ID"}
7
)
8
9
# Define multiple tools
10
tools = [
11
    {
12
        "type": "function",
13
        "function": {
14
            "name": "calculate",
15
            "description": "Perform arithmetic calculations",
16
            "parameters": {
17
                "type": "object",
18
                "properties": {
19
                    "operation": {
20
                        "type": "string",
21
                        "enum": ["add", "subtract", "multiply", "divide"]
22
                    },
23
                    "a": {"type": "number"},
24
                    "b": {"type": "number"}
25
                },
26
                "required": ["operation", "a", "b"]
27
            },
28
            "strict": True
29
        }
30
    },
31
    {
32
        "type": "function",
33
        "function": {
34
            "name": "analyze_sentiment",
35
            "description": "Analyze sentiment of text (positive, negative, neutral)",
36
            "parameters": {
37
                "type": "object",
38
                "properties": {
39
                    "text": {
40
                        "type": "string",
41
                        "description": "Text to analyze"
42
                    }
43
                },
44
                "required": ["text"]
45
            },
46
            "strict": True
47
        }
48
    }
49
]
50
51
# Load large document
52
with open("quarterly_report.txt") as f:
53
    context = f.read()
54
55
# Request with tools
56
response = client.chat.completions.create(
57
    model="captain-voyager-latest",
58
    messages=[
59
        {"role": "system", "content": "You are a financial analysis assistant."},
60
        {"role": "user", "content": "Calculate total Q1-Q4 revenue and analyze overall sentiment"}
61
    ],
62
    tools=tools,
63
    stream=True,
64
    extra_body={
65
        "captain": {
66
            "context": context  # Large quarterly report context
67
        }
68
    }
69
)
70
71
for chunk in response:
72
    if chunk.choices[0].delta.content:
73
        print(chunk.choices[0].delta.content, end="", flush=True)

1
response = client.chat.completions.create(
2
    model="captain-voyager-latest",
3
    messages=[...],
4
    tools=tools,
5
    tool_choice="auto",  # Let model decide (default)
6
    # tool_choice="none",  # Never use tools
7
    stream=True
8
)

1
response = client.chat.completions.create(
2
    model="captain-voyager-latest",
3
    messages=[...],
4
    tools=tools,
5
    stream=True  # Recommended for real-time feedback
6
)
7
8
for chunk in response:
9
    if chunk.choices[0].delta.content:
10
        print(chunk.choices[0].delta.content, end="", flush=True)

1
response = client.chat.completions.create(
2
    model="captain-voyager-latest",
3
    messages=[...],
4
    tools=tools,
5
    stream=False  # Get complete response at once
6
)
7
8
print(response.choices[0].message.content)

1
from openai import OpenAI
2
3
client = OpenAI(
4
    base_url="https://api.runcaptain.com/v1",
5
    api_key="YOUR_API_KEY",
6
    default_headers={"X-Organization-ID": "YOUR_ORG_ID"}
7
)
8
9
# Load very large document (Bible, entire codebase, etc.)
10
with open("very_large_document.txt") as f:
11
    context = f.read()  # Captain handles any size automatically
12
13
# Define tools
14
tools = [{
15
    "type": "function",
16
    "function": {
17
        "name": "calculate",
18
        "description": "Perform arithmetic calculations on values in the document",
19
        "parameters": {
20
            "type": "object",
21
            "properties": {
22
                "operation": {"type": "string", "enum": ["add", "subtract", "multiply", "divide"]},
23
                "a": {"type": "number"},
24
                "b": {"type": "number"}
25
            },
26
            "required": ["operation", "a", "b"]
27
        },
28
        "strict": True
29
    }
30
}]
31
32
# Use standard OpenAI SDK - Captain handles the large context + tool calling
33
response = client.chat.completions.create(
34
    model="captain-voyager-latest",
35
    messages=[
36
        {"role": "system", "content": "You are a financial analysis assistant."},
37
        {"role": "user", "content": "Calculate the total revenue across all quarters"}
38
    ],
39
    tools=tools,
40
    stream=True,
41
    extra_body={
42
        "captain": {
43
            "context": context  # Any size context
44
        }
45
    }
46
)
47
48
for chunk in response:
49
    if chunk.choices[0].delta.content:
50
        print(chunk.choices[0].delta.content, end="", flush=True)

1
from openai import OpenAI
2
3
client = OpenAI(base_url="https://api.runcaptain.com/v1", api_key="...")
4
response = client.chat.completions.create(
5
    model="captain-voyager-latest",
6
    messages=[{"role": "user", "content": "Summarize this"}],
7
    extra_body={"captain": {"context": "Your text here..."}}
8
)

1
import requests
2
3
with open('bible.txt', 'rb') as f:
4
    response = requests.post(
5
        "https://api.runcaptain.com/v1/chat/completions/upload",
6
        headers={"Authorization": f"Bearer {API_KEY}", "X-Organization-ID": ORG_ID},
7
        files={'file': f},
8
        data={'messages': '[{"role":"user","content":"Summarize"}]', 'stream': 'true'},
9
        stream=True
10
    )