# JSON mode — just ensures valid JSON, not schema compliance
response = client.chat.completions.create(
    model="gpt-4o",
    response_format={"type": "json_object"},   # JSON mode
    messages=[{"role": "user", "content": "Extract name and age as JSON"}]
)
data = json.loads(response.choices[0].message.content)
# data["age"] might be "28" or 28 — you don't know

import instructor
from instructor import Mode
from pydantic import BaseModel, field_validator

# Instructor retries automatically when validation fails
client = instructor.from_anthropic(
    anthropic.Anthropic(),
    mode=Mode.ANTHROPIC_JSON,
    max_retries=3   # retry up to 3 times if schema not satisfied
)

class StrictRating(BaseModel):
    score: float
    label: str

    @field_validator("score")
    @classmethod
    def must_be_in_range(cls, v: float) -> float:
        if not (1.0 <= v <= 10.0):
            raise ValueError(f"Score {v} must be between 1.0 and 10.0")
        return round(v, 1)

    @field_validator("label")
    @classmethod
    def must_be_valid_label(cls, v: str) -> str:
        valid = {"excellent", "good", "average", "poor"}
        if v.lower() not in valid:
            raise ValueError(f"Label must be one of {valid}")
        return v.lower()

# If model returns score=11.0, Instructor catches the validation error,
# tells the model what went wrong, and asks it to try again

# Partial extraction — stream partial objects as they are generated
from instructor import Partial

class LargeReport(BaseModel):
    executive_summary: str
    key_findings:      List[str]
    recommendations:   List[str]
    conclusion:        str

# Stream partial object — UI can update progressively
for partial_report in client.messages.create_partial(
    model="claude-3-5-sonnet-20241022",
    max_tokens=4096,
    messages=[{"role": "user", "content": "Generate a quarterly report"}],
    response_model=Partial[LargeReport],
):
    if partial_report.executive_summary:
        print(partial_report.executive_summary, end="
")

import anthropic
import json

client = anthropic.Anthropic()

# STEP 1: Define your Python functions
def get_weather(city: str, units: str = "celsius") -> dict:
    # In production: call a real weather API
    return {"city": city, "temp": 28, "condition": "sunny", "units": units}

def calculate(expression: str) -> dict:
    try:
        result = eval(expression, {"__builtins__": {}})  # safe eval
        return {"result": result, "expression": expression}
    except Exception as e:
        return {"error": str(e)}

# STEP 2: Describe the tools in JSON Schema
tools = [
    {
        "name": "get_weather",
        "description": "Get the current weather for a specific city. Use this when the user asks about weather, temperature, or conditions in a location.",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "The city name, e.g. 'Mumbai', 'Delhi', 'Bangalore'"
                },
                "units": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Temperature unit. Default: celsius"
                }
            },
            "required": ["city"]
        }
    },
    {
        "name": "calculate",
        "description": "Evaluate a mathematical expression. Use this for any arithmetic, percentage, or numeric calculation. Do NOT use this for non-math questions.",
        "input_schema": {
            "type": "object",
            "properties": {
                "expression": {
                    "type": "string",
                    "description": "A valid Python math expression, e.g. '(100 * 1.15) + 50'"
                }
            },
            "required": ["expression"]
        }
    }
]

# STEP 3: Send request with tools
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "What's the weather in Mumbai? Also, what is 15% of 2500?"}]
)

# STEP 4: Execute the tool calls
tool_results = []
for block in response.content:
    if block.type == "tool_use":
        if block.name == "get_weather":
            result = get_weather(**block.input)
        elif block.name == "calculate":
            result = calculate(**block.input)
        tool_results.append({
            "type": "tool_result",
            "tool_use_id": block.id,
            "content": json.dumps(result)
        })

# STEP 5: Send results back to get final response
final_response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    tools=tools,
    messages=[
        {"role": "user",      "content": "What's the weather in Mumbai? Also, 15% of 2500?"},
        {"role": "assistant", "content": response.content},
        {"role": "user",      "content": tool_results}
    ]
)
print(final_response.content[0].text)

# Anthropic tool_choice options

# "auto" (default) — model decides whether to use a tool or respond directly
tool_choice={"type": "auto"}

# "any" — model MUST call a tool (useful to force structured extraction)
tool_choice={"type": "any"}

# Specific tool — model MUST call this exact tool
tool_choice={"type": "tool", "name": "extract_invoice"}

# When to use each:
# "auto"     — conversational agents where tool use is optional
# "any"      — when you always need structured output (extraction pipelines)
# specific   — when you know exactly which tool to force (single-purpose endpoints)

# OpenAI equivalents
tool_choice = "auto"       # let model decide
tool_choice = "required"   # must use a tool (= Anthropic "any")
tool_choice = "none"       # never use tools
tool_choice = {"type": "function", "function": {"name": "get_weather"}}  # force specific