Finer control,
with code

pip install --upgrade openai requests

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["UPSTAGE_API_KEY"],
    base_url="https://api.upstage.ai/v1",
)

MODEL = "solar-pro4"   # covered by the AI Initiative

messages = [
    {"role": "user", "content": "My favourite colour is green."}
]

first = client.chat.completions.create(model=MODEL, messages=messages)
messages.append({"role": "assistant", "content": first.choices[0].message.content})

# Second turn — it can answer because we sent the earlier exchange
messages.append({"role": "user", "content": "What did I say my favourite colour was?"})

second = client.chat.completions.create(model=MODEL, messages=messages)
print(second.choices[0].message.content)

import json

response = client.chat.completions.create(
    model=MODEL,
    messages=[{
        "role": "user",
        "content": "Classify this enquiry and draft a short reply: I was charged twice for my subscription."
    }],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "inquiry",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "category": {
                        "type": "string",
                        "enum": ["billing", "technical", "account"],
                        "description": "The category the enquiry belongs to"
                    },
                    "urgent": {
                        "type": "boolean",
                        "description": "Whether it needs an immediate response"
                    },
                    "reply": {
                        "type": "string",
                        "description": "A short reply to send to the customer"
                    }
                },
                "required": ["category", "urgent", "reply"],
                "additionalProperties": False
            }
        }
    }
)

if response.choices[0].finish_reason != "stop":
    raise RuntimeError("The response was cut off. Increase max_tokens or retry.")

result = json.loads(response.choices[0].message.content)
print(result["category"], result["urgent"])
print(result["reply"])

tools = [{
    "type": "function",
    "function": {
        "name": "get_budget",
        "description": "Look up budget execution status by department and year.",
        "parameters": {
            "type": "object",
            "properties": {
                "department": {"type": "string", "description": "Department name"},
                "year": {"type": "integer", "description": "Year to look up"}
            },
            "required": ["department", "year"],
            "additionalProperties": False
        }
    }
}]

messages = [{"role": "user", "content": "What is the 2026 budget execution rate for the education team?"}]

response = client.chat.completions.create(
    model=MODEL,
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

import json

tool_calls = response.choices[0].message.tool_calls

if tool_calls:
    messages.append(response.choices[0].message)

    for call in tool_calls:
        # 1) Confirm it is a tool you allow
        if call.function.name != "get_budget":
            raise ValueError(f"Tool not allowed: {call.function.name}")

        # 2) Confirm the values have the right shape
        args = json.loads(call.function.arguments)
        department = args.get("department")
        year = args.get("year")
        if not isinstance(department, str) or not department.strip():
            raise ValueError("department must be a non-empty string")
        if not isinstance(year, int):
            raise ValueError("year must be an integer")

        # 3) Only then run it
        result = get_budget(department=department, year=year)

        messages.append({
            "tool_call_id": call.id,
            "role": "tool",
            "name": call.function.name,
            "content": json.dumps(result),
        })

    final = client.chat.completions.create(model=MODEL, messages=messages)
    print(final.choices[0].message.content)

import os
import requests

url = "https://api.upstage.ai/v1/document-digitization"
headers = {"Authorization": f"Bearer {os.environ['UPSTAGE_API_KEY']}"}

with open("sample.pdf", "rb") as f:
    response = requests.post(
        url,
        headers=headers,
        files={"document": f},
        data={"model": "document-parse", "ocr": "force"},
    )

result = response.json()

print(result["content"]["html"][:500])   # structure preserved
print(result["usage"]["pages"], "pages processed")

import time
import glob

results = {}

for path in glob.glob("documents/*.pdf"):
    try:
        with open(path, "rb") as f:
            response = requests.post(
                url,
                headers=headers,
                files={"document": f},
                data={"model": "document-parse", "ocr": "force"},
            )

        if response.status_code == 429:
            time.sleep(3)          # over the limit — wait a moment
            continue

        response.raise_for_status()
        results[path] = response.json()["content"]["html"]
        print(f"done: {path}")

    except Exception as e:
        print(f"failed: {path} — {e}")

    time.sleep(1)                  # stay within 1 request per second

import json

# Step 1 — turn the document into text
with open("receipt.pdf", "rb") as f:
    parsed = requests.post(
        url, headers=headers,
        files={"document": f},
        data={"model": "document-parse", "ocr": "force"},
    ).json()

document_text = parsed["content"]["html"]

# Steps 2 and 3 — extract values and judge against criteria
response = client.chat.completions.create(
    model=MODEL,
    messages=[{
        "role": "user",
        "content": f"From the receipt below, find the merchant, date, and total. "
                   f"If the total is over 100000, mark it as HOLD.\n\n{document_text}"
    }],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "receipt",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "store_name":   {"type": ["string", "null"], "description": "merchant name at the top"},
                    "issued_date":  {"type": ["string", "null"], "description": "date of issue"},
                    "total_amount": {"type": ["integer", "null"], "description": "final amount including tax"},
                    "decision":     {"type": "string", "enum": ["APPROVE", "HOLD", "NEEDS_CHECK"]},
                    "reason":       {"type": "string", "description": "one sentence explaining the decision"}
                },
                "required": ["store_name", "issued_date", "total_amount", "decision", "reason"],
                "additionalProperties": False
            }
        }
    }
)

print(json.loads(response.choices[0].message.content))

https://console.upstage.ai/api/docs/for-agents/raw

Read the URL above first.
For the Upstage API, use only the spec in that document —
do not fill in gaps from memory.

# Upstage API rules for this project

## Read first
- https://console.upstage.ai/api/docs/for-agents/raw
- Use only the spec in that document. Do not rely on memory.

## Hard rules
- Use `solar-pro4` only for the language model.
  `solar-mini` and the rest of the Solar family are forbidden — outside the
  AI Initiative, so the call fails. (`solar-pro2` and `solar-pro3` are also
  covered, but standardise new code on `solar-pro4`.)
- Use `document-parse` only for document processing.
  `information-extract`, `document-classify` and the embedding models
  (`solar-embedding-2-query`, `solar-embedding-2-passage`)
  are forbidden — they draw down credits.
- Do not reach for a separate product for field extraction or classification.
  Convert with Document Parse, then use Solar structured outputs.

## Addresses
- Solar          : https://api.upstage.ai/v1  (OpenAI-compatible, openai library)
- Document Parse : https://api.upstage.ai/v1/document-digitization  (multipart/form-data)
- The two responses are shaped differently.
  Solar: choices[0].message.content. Document Parse: content.html / elements[].

## Keys
- Never write the key in code. Always read os.environ["UPSTAGE_API_KEY"].
- Never leave the key value in logs, comments, or commits.

## Limits
- Tier 0: 100 requests and 50,000 tokens per minute. Document Parse: 1 per second.
- Any loop must include a delay between calls and a 429 retry.

## Handling results
- structured outputs: strict: true, additionalProperties: false,
  every field in required. Open optional fields as ["string", "null"].
- Check finish_reason == "stop" before reading the response.
- Leave a human review step for amounts and dates.

# Format design for my task

## Input
- Document format:
- How many at a time:
- Is Document Parse needed (yes / no):

## Fields to extract
| Field name | Description | Type | Can it be empty |
|---|---|---|---|
|  |  |  |  |
|  |  |  |  |
|  |  |  |  |

## Verdict values
- Allowed values (enum):
- The criteria for each, as numbers and conditions:

## Validation
- Values a person must always check:
- What to do when a value looks wrong:

## Failure handling
- On a 429:
- On an empty value:

## Fields to extract
| applicant_org    | Name of the applying organization      | string  | no  |
| project_title    | Project name                           | string  | no  |
| requested_amount | Amount requested (integer)             | integer | yes |
| attachments      | List of attached document names        | array   | yes |

## Verdict values
- enum: ["ACCEPT", "NEEDS_REVISION", "NEEDS_CHECK"]
- ACCEPT: all required fields present and the amount is 50,000,000 or less
- NEEDS_REVISION: at least one required attachment is missing
- NEEDS_CHECK: the amount or organization name could not be found

## Validation
- A person always checks: requested_amount
- When a value looks wrong: mark NEEDS_CHECK and pass it to the officer

## Failure handling
- On a 429: wait 3 seconds and retry, up to three times
- On an empty value: mark NEEDS_CHECK and record the source page number