Chapter 2. Overview of OGX

# List models available in the ogx server
models = client.models.list()
rich.print(models)

# Select the first LLM and first embedding model
model_id = next(m for m in models if m.custom_metadata["model_type"] == "llm").id
embedding_model_id = (
    em := next(m for m in models if m.custom_metadata["model_type"] == "embedding")
).id
embedding_dimension = em.custom_metadata["embedding_dimension"]

# Test chat completion functionality with a simple question
response = client.chat.completions.create(
    model=model_id,
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is the capital of France?"},
    ],
    temperature=0,
)
# Optional verification check
assert len(response.choices) > 0, "No response after basic inference on ogx server"
content = response.choices[0].message.content
rich.print(content)

# Test completion functionality with a simple question
response = client.completions.create(
    model=model_id,
    prompt="Answer with one word only: What is the capital of France?",
    max_tokens=64,
    temperature=0.1
)
# Optional verification check
assert len(response.choices) > 0, "No response after basic inference on ogx server"
content = response.choices[0].text
rich.print(content)

# Create text embeddings
response = client.embeddings.create(
    input="Your text string goes here",
    model=embedding_model_id
)
embedding = response.data[0].embedding
rich.print(embedding[:5] + ["..."] + embedding[-5:])

import requests
from rich import print
from rich.rule import Rule
import time

# -----------------------------
# Download the PDF from url
# -----------------------------
print(Rule("[bold cyan]Downloading PDF[/bold cyan]"))

# We'll use IBM 2025-Q4 report to test RAG, as models don't have that info
pdf_url = "https://www.ibm.com/downloads/documents/us-en/1550f7eea8c0ded6"
filename = "ibm-Q4-2025-4q25-press-release.pdf"
title = "IBM-4Q25-Earnings-Press-Release"

print("📥 Fetching PDF from URL...")
response = requests.get(pdf_url)
response.raise_for_status()
print("✅ PDF fetched successfully")

print(f"💾 Saving PDF as [bold]{filename}[/bold]...")
with open(filename, "wb") as f:
    f.write(response.content)
print(f"✅ Downloaded and saved: [green]{filename}[/green]")

# -----------------------------
# Upload the PDF
# -----------------------------
print(Rule("[bold cyan]Uploading File[/bold cyan]"))

print("☁️ Uploading file to Files API...")
with open(filename, "rb") as f:
    file_info = client.files.create(
        file=(filename, f),
        purpose="assistants"
    )

print("✅ File uploaded successfully")
print(file_info)

# -----------------------------
# Create vector store
# -----------------------------
print(Rule("[bold cyan]Creating Vector Store[/bold cyan]"))

provider_id = "milvus-remote"

print("🧠 Creating vector store with Milvus provider...")
vector_store = client.vector_stores.create(
    name="test_vector_store",
    extra_body={
        "embedding_model": embedding_model_id,
        "embedding_dimension": embedding_dimension,
        "provider_id": provider_id,
    },
)

print("✅ Vector store created")
print(vector_store)

# -----------------------------
# Add file to vector store
# -----------------------------
print(Rule("[bold cyan]Indexing File[/bold cyan]"))

print("📎 Adding uploaded file to vector store...")
vector_store_file = client.vector_stores.files.create(
    vector_store_id=vector_store.id,
    file_id=file_info.id,
    chunking_strategy={
        "type": "static",
        "static": {
            "max_chunk_size_tokens": 700,
            "chunk_overlap_tokens": 100,
        }
    },
    attributes={
        "title": title,
    },
)

print("✅ File added to vector store")
print(vector_store_file)

# -----------------------------
# Verify file is completed
# -----------------------------
print(Rule("[bold cyan]Waiting until file status is complete[/bold cyan]"))


# Wait for file processing to complete
print("Waiting for file processing to complete...")
max_wait_time = 300  # 5 minutes
start_time = time.time()

while time.time() - start_time < max_wait_time:
    files = client.vector_stores.files.list(vector_store_id=vector_store.id)
    if files.data:
        file_status = files.data[0].status
        print(f"File status: {file_status}")
        if file_status == "completed":
            print("✅ File processing completed!")
            break
        elif file_status == "failed":
            print("✗ File processing failed!")
            break
    time.sleep(5)
else:
    print("⚠ Timeout waiting for file processing")

# Verify file is completed
files = client.vector_stores.files.list(vector_store_id=vector_store.id)
if files.data:
    print(f"\nFinal file status: {files.data[0].status}")
    print(f"File details: {files.data[0]}")
else:
    print("No files found in vector store")

print(Rule("[bold green]All tasks completed successfully ✔[/bold green]"))

from rich import print
from rich.table import Table

system_instructions = """You are a financial document analysis assistant specialized in quarterly earnings reports, annual filings, press releases, and earnings call transcripts.
You are designed to answer questions in a concise and professional manner.
Answer questions strictly using only the provided documents.
Base every answer strictly on the retrieved document content and cite the relevant section or excerpt ID.
Do not use outside knowledge.
Do not guess, infer missing data, or fabricate numbers.
If the answer is not found in the retrieved content, reply: "I couldn't find relevant information in the available files or my own knowledge."
Be concise, precise, and factual."""

examples = [
     {
        "input_query": "What do you know about IBM earnings in Q4, 2025?  Summarize in one sentence",
        "expected_answer": "IBM reported strong fourth-quarter results with revenue rising 12% to $19.7 billion, driven by double-digit growth in its Software and Infrastructure segments and a generative AI book of business that has now surpassed $12.5 billion"
    },
    {
        "input_query": "What was the total value of IBM's generative AI book of business as reported in the fourth quarter of 2025?",
        "expected_answer": "IBM reported that its generative AI book of business now stands at more than $12.5 billion."
    },
    {
        "input_query": "What was IBM's reported free cash flow for the full year of 2025?",
        "expected_answer": (
            "IBM reported a full-year free cash flow of $14.7 billion, which was an increase of $2.0 billion year-over-year"
        )
    },
    {
        "input_query": "How did the Software segment perform in terms of revenue during the fourth quarter of 2025?",
        "expected_answer": (
            "The Software segment generated $9.0 billion in revenue, representing an increase of 14 percent (or 11 percent at constant currency)"
        )
    },
]

# Use the Responses API to create a results table comparing not using vs using
# the vector_store
table = Table(
    title="Answer Comparison (With vs Without Vector Store)",
    show_lines=True,
)

table.add_column("Question", style="cyan", no_wrap=False)
table.add_column("Expected Answer", style="magenta", no_wrap=False)
table.add_column("Answer (No Vector Store)", style="yellow", no_wrap=False)
table.add_column("Answer (With Vector Store)", style="green", no_wrap=False)

for example in examples:
    question = example["input_query"]
    expected_answer = example["expected_answer"]

    # Ask question without vector_store
    response_no_vs = client.responses.create(
        model=model_id,
        input=question,
        instructions=system_instructions,
    )
    answer_no_vs = response_no_vs.output_text.strip()

    # Ask question with vector_store
    response_vs = client.responses.create(
        model=model_id,
        input=question,
        instructions=system_instructions,
        tools=[
            {
                "type": "file_search",
                "vector_store_ids": [vector_store.id],
            }
        ],
    )
    answer_vs = response_vs.output_text.strip()

    table.add_row(
        question,
        expected_answer,
        answer_no_vs,
        answer_vs,
    )

# The table will take a while to be printed, as multiple queries to the responses API will be done
print(table)

model_id = "your-model-id"

# Step 1: Create a conversation
conversation = client.conversations.create(
    metadata={"topic": "pet-care", "user": "demo-user"}
)
conversation_id = conversation.id

# Step 2: Send messages using the Responses API with conversation_id
# Turn 1
response1 = client.responses.create(
    model=model_id,
    input="I have a rabbit. What is its living quarters called?",
    conversation=conversation_id,
    store=True,  # Persist each response as a conversation item
    instructions="You are a helpful assistant. Keep responses brief.",
)
print(response1.output_text)

# Turn 2: The response can use context from Turn 1
response2 = client.responses.create(
    model=model_id,
    input="I also have a dog. What are its living quarters called?",
    conversation=conversation_id,
    store=True,
)
print(response2.output_text)

# Turn 3: The response can use context from previous turns
response3 = client.responses.create(
    model=model_id,
    input="List the living quarters I need for all my pets.",
    conversation=conversation_id,
    store=True,
)
print(response3.output_text)

# Step 3: List all messages in the conversation
items = client.conversations.items.list(conversation_id, order="asc")
for item in items.data:
    print(f"{item.role}: {item.content}")

# Step 4: Clean up
client.conversations.delete(conversation_id)

"output": [
  {
    "content": [
      {
        "type": "output_text",
        "text": "Example generated response.",
        "annotations": [ ... ]
      }
    ]
  }
]