Forge API documentation.

from openai import OpenAI

client = OpenAI(
    base_url="https://forge-api.lanaai.io/v1",
    api_key="your-forge-api-key",
)

response = client.chat.completions.create(
    model="auto",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "What does this contract clause say?"},
            {"type": "image_url",
             "image_url": {"url": "https://example.com/clause.png"}},
        ],
    }],
)
# Or inline a base64 data URI: "data:image/png;base64,iVBORw0KG..."
print(response.choices[0].message.content)

# Extract text/answers from a PDF, Word, PowerPoint or Excel file
curl https://forge-api.lanaai.io/v1/documents \
  -H "Authorization: Bearer $FORGE_API_KEY" \
  -F "file=@contract.pdf" \
  -F "prompt=Summarize the indemnification terms"

# Native text where the layer exists, vision OCR where it
# does not. Set "X-Sovereign: true" to keep extraction on
# the LANA model only, with zero retention.

from openai import OpenAI

client = OpenAI(
    base_url="https://forge-api.lanaai.io/v1",
    api_key="your-forge-api-key",
)

# Stream tokens as they generate
stream = client.chat.completions.create(
    model="auto",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Explain machine learning in 3 paragraphs"},
    ],
    stream=True,
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

// npm install openai
import OpenAI from "openai";

const client = new OpenAI({
    baseURL: "https://forge-api.lanaai.io/v1",
    apiKey: process.env.FORGE_API_KEY,
});

export async function POST(req: Request) {
    const { messages } = await req.json();

    const stream = await client.chat.completions.create({
        model: "auto",
        messages,
        stream: true,
    });

    // Return as a streaming response
    return new Response(stream.toReadableStream(), {
        headers: { "Content-Type": "text/event-stream" },
    });
}

from openai import OpenAI

client = OpenAI(
    base_url="https://forge-api.lanaai.io/v1",
    api_key="your-forge-api-key",
)

# Step 1: Embed your documents
docs = ["Forge is an AI gateway", "It supports sovereign mode"]
embeddings = client.embeddings.create(
    model="embedding",
    input=docs,
)
vectors = [e.embedding for e in embeddings.data]
# Store vectors in your database (Pinecone, Weaviate, pgvector, etc.)

# Step 2: Query with context
query = "What is sovereign mode?"
query_vec = client.embeddings.create(model="embedding", input=query)
# Search your vector DB for similar docs...
relevant_docs = ["It supports sovereign mode"]  # from vector search

# Step 3: Generate answer with retrieved context
response = client.chat.completions.create(
    model="auto",
    messages=[
        {"role": "system", "content": f"Answer based on: {relevant_docs}"},
        {"role": "user", "content": query},
    ],
)

import json
from openai import OpenAI

client = OpenAI(
    base_url="https://forge-api.lanaai.io/v1",
    api_key="your-forge-api-key",
)

# Define your tools
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string"}
            },
            "required": ["city"]
        }
    }
}]

response = client.chat.completions.create(
    model="auto",
    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}],
    tools=tools,
)

# Model returns a tool call, execute it and send the result back
tool_call = response.choices[0].message.tool_calls[0]
print(f"Call: {tool_call.function.name}({tool_call.function.arguments})")

# pip install langchain-openai
from langchain_openai import ChatOpenAI, OpenAIEmbeddings

# Use Forge as your LLM
llm = ChatOpenAI(
    base_url="https://forge-api.lanaai.io/v1",
    api_key="your-forge-api-key",
    model="auto",
)

# Use Forge for embeddings too
embeddings = OpenAIEmbeddings(
    base_url="https://forge-api.lanaai.io/v1",
    api_key="your-forge-api-key",
    model="embedding",
)

# Works with any LangChain chain
response = llm.invoke("What is Forge?")
print(response.content)

from openai import OpenAI, APIError, RateLimitError, AuthenticationError

client = OpenAI(
    base_url="https://forge-api.lanaai.io/v1",
    api_key="your-forge-api-key",
)

try:
    response = client.chat.completions.create(
        model="auto",
        messages=[{"role": "user", "content": "Hello"}],
    )
except AuthenticationError:
    print("Invalid API key")
except RateLimitError as e:
    print(f"Rate limited. Retry after: {e.response.headers.get('Retry-After')}s")
except APIError as e:
    if e.status_code == 429:
        print("Monthly quota exceeded, upgrade your plan")
    elif e.status_code == 503:
        print("Sovereign mode: self-hosted model unavailable")
    else:
        print(f"API error: {e}")