# 1. Install Google Cloud SDK
curl https://sdk.cloud.google.com | bash

# 2. Initialize and authenticate
gcloud init
gcloud auth application-default login

# 3. Enable Vertex AI API
gcloud services enable aiplatform.googleapis.com

# 4. Install the Anthropic Python library
pip install anthropic

# 5. Verify access
python -c "from anthropic import AnthropicVertex; print('OK')"

from anthropic import AnthropicVertex

# Explicit configuration — recommended for production
client = AnthropicVertex(
    region="us-east5",           # GCP region with Claude access
    project_id="my-gcp-project"  # Your GCP project ID
)

import os
# Set env vars: ANTHROPIC_VERTEX_PROJECT_ID, CLOUD_ML_REGION
os.environ["ANTHROPIC_VERTEX_PROJECT_ID"] = "my-gcp-project"
os.environ["CLOUD_ML_REGION"] = "us-east5"
client = AnthropicVertex()  # reads from env

from anthropic import AnthropicVertex

client = AnthropicVertex(region="us-east5", project_id="my-gcp-project")

message = client.messages.create(
    model="claude-3-5-sonnet@20241022",
    max_tokens=1024,
    system="You are a helpful assistant.",
    messages=[
        {"role": "user", "content": "What is the capital of France?"}
    ]
)

# Accessing response content
print(message.content[0].text)           # "Paris is the capital of France."
print(f"Stop reason: {message.stop_reason}")  # "end_turn"
print(f"Input tokens:  {message.usage.input_tokens}")
print(f"Output tokens: {message.usage.output_tokens}")
print(f"Model: {message.model}")

from anthropic import AnthropicVertex

client = AnthropicVertex(region="us-east5", project_id="my-gcp-project")

conversation_history = []
system_prompt = "You are a helpful Python tutor. Be concise and give working code examples."

def chat(user_input: str) -> str:
    # Add user turn
    conversation_history.append({"role": "user", "content": user_input})

    response = client.messages.create(
        model="claude-3-5-sonnet@20241022",
        max_tokens=2048,
        system=system_prompt,
        messages=conversation_history
    )

    # Extract and store assistant turn
    assistant_msg = response.content[0].text
    conversation_history.append({"role": "assistant", "content": assistant_msg})
    return assistant_msg

# Example multi-turn session
print(chat("What is a list comprehension?"))
# Returns explanation

print(chat("Show me three examples."))
# References the previous exchange (list comprehensions)

print(chat("Now convert the last example to a generator expression."))
# Refers to the third example from the prior turn

def trim_history(history: list, max_pairs: int = 10) -> list:
    """Keep only the most recent N user/assistant pairs."""
    # Always keep pairs (user + assistant = 2 items)
    max_items = max_pairs * 2
    if len(history) > max_items:
        return history[-max_items:]
    return history

# Simple string system prompt
response = client.messages.create(
    model="claude-3-5-sonnet@20241022",
    max_tokens=512,
    system="You are a senior software engineer. Always provide code examples in Python.",
    messages=[{"role": "user", "content": "How do I read a file?"}]
)

# Structured system prompt with XML tags
system = """
<role>You are a customer support agent for Acme Corp.</role>
<tone>Professional, empathetic, solution-focused</tone>
<constraints>
- Never promise refunds without authorization code
- Escalate billing issues to finance team
- Always end with: "Is there anything else I can help you with?"
</constraints>
<knowledge_cutoff>You have product information current as of 2024-Q4.</knowledge_cutoff>
"""

# System prompt as list (for prompt caching — covered in Module 7)
system_as_list = [
    {
        "type": "text",
        "text": "You are a helpful assistant with a large corpus of knowledge.",
        "cache_control": {"type": "ephemeral"}  # Cache this block
    }
]

# Deterministic output — best for extraction, classification, structured data
response = client.messages.create(
    model="claude-3-5-sonnet@20241022",
    max_tokens=256,
    temperature=0.0,   # Fully deterministic
    messages=[{"role": "user", "content": "Is 'The weather is nice' positive or negative?"}]
)

# Creative output — stories, brainstorming, variation generation
response = client.messages.create(
    model="claude-3-5-sonnet@20241022",
    max_tokens=1024,
    temperature=1.0,   # Maximum creativity
    messages=[{"role": "user", "content": "Write an unexpected plot twist for a mystery novel."}]
)

# Top-p (nucleus) sampling — alternative to temperature
response = client.messages.create(
    model="claude-3-5-sonnet@20241022",
    max_tokens=256,
    top_p=0.9,    # Consider tokens comprising top 90% probability mass
    messages=[{"role": "user", "content": "Write a tagline for a coffee brand."}]
)

# Top-k — limit to top k tokens
response = client.messages.create(
    model="claude-3-5-sonnet@20241022",
    max_tokens=256,
    top_k=50,     # Only sample from the 50 most likely next tokens
    messages=[{"role": "user", "content": "Continue this sentence: The rocket launched and"}]
)

# Stop generation when a specific string is produced
response = client.messages.create(
    model="claude-3-5-sonnet@20241022",
    max_tokens=1024,
    stop_sequences=["</answer>", "###", "STOP"],
    messages=[{
        "role": "user",
        "content": "Solve this: What is 15% of 200? Wrap your answer in <answer></answer> tags."
    }]
)
# Claude generates until it produces </answer> — then stops
# Useful to extract content between tags without trailing text
print(response.stop_reason)       # "stop_sequence"
print(response.stop_sequence)     # "</answer>"

from anthropic import AnthropicVertex

client = AnthropicVertex(region="us-east5", project_id="my-gcp-project")

# Simple streaming — iterate over text chunks
with client.messages.stream(
    model="claude-3-5-sonnet@20241022",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Write a haiku about Google Cloud Platform."}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
print()

# Access final message after streaming completes
with client.messages.stream(
    model="claude-3-5-sonnet@20241022",
    max_tokens=2048,
    messages=[{"role": "user", "content": "Explain Vertex AI in detail."}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

    final_message = stream.get_final_message()
    print(f"\nTotal output tokens: {final_message.usage.output_tokens}")

# Raw event streaming — for fine-grained control
with client.messages.stream(
    model="claude-3-5-sonnet@20241022",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Count to 5."}]
) as stream:
    for event in stream:
        if event.type == "content_block_delta":
            print(f"[delta]: {event.delta.text}", end="")
        elif event.type == "message_stop":
            print("\n[stream complete]")

import json
from anthropic import AnthropicVertex

client = AnthropicVertex(region="us-east5", project_id="my-gcp-project")

# Method 1: System prompt instruction + JSON parsing
response = client.messages.create(
    model="claude-3-5-sonnet@20241022",
    max_tokens=512,
    system="Always respond with valid JSON only. No explanation, no markdown code fences.",
    messages=[{
        "role": "user",
        "content": "Extract: name, age, city from: 'John is 30 years old from London.'"
    }]
)
data = json.loads(response.content[0].text)
print(data)  # {"name": "John", "age": 30, "city": "London"}

# Method 2: Prefill the assistant turn to force JSON
response = client.messages.create(
    model="claude-3-5-sonnet@20241022",
    max_tokens=512,
    messages=[
        {"role": "user", "content": "List three GCP regions as JSON array of strings."},
        {"role": "assistant", "content": "["}  # Prefill forces Claude to continue JSON
    ]
)
# Response will complete the JSON array
raw = "[" + response.content[0].text
regions = json.loads(raw)

# Method 3: XML-delimited extraction
response = client.messages.create(
    model="claude-3-5-sonnet@20241022",
    max_tokens=512,
    messages=[{
        "role": "user",
        "content": """Extract the sentiment and confidence score.
Respond ONLY with XML:
<result>
  <sentiment>POSITIVE|NEGATIVE|NEUTRAL</sentiment>
  <confidence>0.0-1.0</confidence>
</result>

Text: "This product completely exceeded my expectations!"
"""
    }]
)

import xml.etree.ElementTree as ET
root = ET.fromstring(response.content[0].text.strip())
sentiment = root.find("sentiment").text
confidence = float(root.find("confidence").text)

import asyncio
from anthropic import AsyncAnthropicVertex

async def main():
    client = AsyncAnthropicVertex(region="us-east5", project_id="my-gcp-project")

    # Single async request
    response = await client.messages.create(
        model="claude-3-5-sonnet@20241022",
        max_tokens=1024,
        messages=[{"role": "user", "content": "Explain async/await in Python."}]
    )
    print(response.content[0].text)

    # Parallel async requests
    tasks = [
        client.messages.create(
            model="claude-3-5-haiku@20241022",
            max_tokens=256,
            messages=[{"role": "user", "content": f"Summarize: Topic {i}"}]
        )
        for i in range(5)
    ]
    results = await asyncio.gather(*tasks)
    for r in results:
        print(r.content[0].text)

asyncio.run(main())

from anthropic import AnthropicVertex
from anthropic import APIStatusError, APIConnectionError, APITimeoutError, RateLimitError
import time

client = AnthropicVertex(region="us-east5", project_id="my-gcp-project")

def create_with_retry(messages: list, max_retries: int = 3) -> str:
    for attempt in range(max_retries):
        try:
            response = client.messages.create(
                model="claude-3-5-sonnet@20241022",
                max_tokens=1024,
                messages=messages
            )
            return response.content[0].text

        except RateLimitError as e:
            wait = 2 ** attempt  # exponential backoff: 1s, 2s, 4s
            print(f"Rate limited. Waiting {wait}s before retry {attempt+1}/{max_retries}")
            time.sleep(wait)

        except APIConnectionError as e:
            print(f"Connection error: {e}. Retrying...")
            time.sleep(1)

        except APITimeoutError as e:
            print(f"Request timed out on attempt {attempt+1}")
            time.sleep(1)

        except APIStatusError as e:
            print(f"API error {e.status_code}: {e.message}")
            if e.status_code in (400, 401, 403):
                raise  # Don't retry auth/validation errors
            time.sleep(2 ** attempt)

    raise RuntimeError(f"Failed after {max_retries} retries")

from anthropic import AnthropicVertex
import json

client = AnthropicVertex(region="us-east5", project_id="my-gcp-project")

def generate_test_dataset(task_description: str, n_examples: int = 30) -> list:
    """Use Claude to generate labeled test cases for a classification task."""
    response = client.messages.create(
        model="claude-3-5-sonnet@20241022",
        max_tokens=4096,
        messages=[{
            "role": "user",
            "content": f"""Generate {n_examples} diverse test examples for this task:
{task_description}

Return as JSON array where each item has:
- "input": the test input text
- "expected_label": the correct answer
- "category": one of [normal, edge_case, adversarial]

Ensure balanced distribution across categories and classes.
Return ONLY the JSON array."""
        }]
    )
    return json.loads(response.content[0].text)

# Example usage
dataset = generate_test_dataset(
    "Sentiment classification: classify customer reviews as POSITIVE, NEGATIVE, or NEUTRAL"
)

def grade_exact(output: str, expected: str) -> bool:
    return output.strip().upper() == expected.strip().upper()

import re

def grade_regex(output: str, pattern: str) -> bool:
    return bool(re.search(pattern, output, re.IGNORECASE))

# Example: check if output contains a valid date format
grade_regex(output, r'\d{4}-\d{2}-\d{2}')

import jsonschema
import json

schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer"},
        "city": {"type": "string"}
    },
    "required": ["name", "age", "city"]
}

def grade_json_schema(output: str, schema: dict) -> bool:
    try:
        data = json.loads(output)
        jsonschema.validate(data, schema)
        return True
    except (json.JSONDecodeError, jsonschema.ValidationError):
        return False

def grade_with_claude(output: str, expected: str, criterion: str) -> dict:
    """Use Haiku for cost-efficient grading."""
    grading_response = client.messages.create(
        model="claude-3-5-haiku@20241022",   # Use cheaper model for grading
        max_tokens=100,
        messages=[{
            "role": "user",
            "content": f"""Evaluate if the response meets the criterion.

Criterion: {criterion}
Expected (reference): {expected}
Actual response: {output}

Respond with JSON only:
{{"pass": true/false, "score": 0.0-1.0, "reason": "one sentence explanation"}}"""
        }]
    )
    return json.loads(grading_response.content[0].text)

# Usage
result = grade_with_claude(
    output="Paris is the capital city of France, located in northern France.",
    expected="Paris",
    criterion="The response correctly identifies the capital of France."
)
# {"pass": true, "score": 1.0, "reason": "Response correctly names Paris as France's capital."}

import json
import time
from datetime import datetime

def run_evaluation(
    test_dataset: list,
    prompt_template: str,
    model: str = "claude-3-5-sonnet@20241022"
) -> dict:
    """Run full evaluation and return metrics."""
    results = []

    for i, example in enumerate(test_dataset):
        # Format prompt with input
        user_message = prompt_template.format(input=example["input"])

        response = client.messages.create(
            model=model,
            max_tokens=256,
            temperature=0,
            messages=[{"role": "user", "content": user_message}]
        )

        actual = response.content[0].text.strip()
        correct = grade_exact(actual, example["expected_label"])

        results.append({
            "input": example["input"],
            "expected": example["expected_label"],
            "actual": actual,
            "correct": correct,
            "category": example.get("category", "normal"),
            "input_tokens": response.usage.input_tokens,
            "output_tokens": response.usage.output_tokens
        })

        # Rate limit respect
        if i > 0 and i % 10 == 0:
            time.sleep(1)

    # Compute metrics
    total = len(results)
    correct = sum(1 for r in results if r["correct"])
    accuracy = correct / total

    # Break down by category
    by_category = {}
    for r in results:
        cat = r["category"]
        if cat not in by_category:
            by_category[cat] = {"correct": 0, "total": 0}
        by_category[cat]["total"] += 1
        if r["correct"]:
            by_category[cat]["correct"] += 1

    return {
        "timestamp": datetime.utcnow().isoformat(),
        "model": model,
        "accuracy": accuracy,
        "correct": correct,
        "total": total,
        "by_category": by_category,
        "avg_input_tokens": sum(r["input_tokens"] for r in results) / total,
        "avg_output_tokens": sum(r["output_tokens"] for r in results) / total,
        "results": results
    }

<system_context>
You are a content moderation assistant for a B2B SaaS platform.
Your task is to classify support tickets by urgency.
</system_context>

<urgency_definitions>
<level name="P0">Production down, all users affected — respond in 15 minutes</level>
<level name="P1">Partial outage, major feature broken — respond in 1 hour</level>
<level name="P2">Non-blocking bug or feature question — respond in 24 hours</level>
<level name="P3">Feature request or cosmetic — respond in 1 week</level>
</urgency_definitions>

<examples>
<example>
<ticket>Our login system is completely broken, nobody can access the app!</ticket>
<priority>P0</priority>
</example>
<example>
<ticket>The export CSV button shows wrong column headers</ticket>
<priority>P2</priority>
</example>
</examples>

<task>
Classify this ticket. Respond with only: P0, P1, P2, or P3.
<ticket>{ticket_text}</ticket>
</task>

few_shot_system = """
You extract structured data from natural language. Return JSON only.

Examples:
Input: "Sarah Johnson, 42, lives in Austin Texas"
Output: {"name": "Sarah Johnson", "age": 42, "city": "Austin", "state": "Texas"}

Input: "Bob, 28, from New York"
Output: {"name": "Bob", "age": 28, "city": "New York", "state": "NY"}

Input: "Dr. Emily Chen is 55 and based in Chicago"
Output: {"name": "Emily Chen", "age": 55, "city": "Chicago", "state": "IL"}
"""

response = client.messages.create(
    model="claude-3-5-sonnet@20241022",
    max_tokens=256,
    system=few_shot_system,
    messages=[{
        "role": "user",
        "content": "Maria Rodriguez, 31, from Los Angeles California"
    }]
)

# Standard CoT — ask Claude to think step by step
cot_response = client.messages.create(
    model="claude-3-5-sonnet@20241022",
    max_tokens=2048,
    messages=[{
        "role": "user",
        "content": """Solve this problem step by step, then give your final answer.

A store sells apples for $0.50 each and oranges for $0.75 each.
If Alex bought 8 apples and 5 oranges, and paid with a $10 bill,
how much change did Alex receive?

Show your work clearly, then state the final answer."""
    }]
)

# Structured CoT with XML — extract reasoning and answer separately
structured_cot = client.messages.create(
    model="claude-3-5-sonnet@20241022",
    max_tokens=2048,
    messages=[{
        "role": "user",
        "content": """Analyze whether this investment is worthwhile.
Put your reasoning in <thinking> tags and your recommendation in <recommendation> tags.

Investment: $50,000 upfront, returns $8,000/year for 8 years"""
    }]
)

import re
text = structured_cot.content[0].text
thinking = re.search(r'<thinking>(.*?)</thinking>', text, re.DOTALL)
recommendation = re.search(r'<recommendation>(.*?)</recommendation>', text, re.DOTALL)

# Technical expert role
technical_system = """
You are a principal Google Cloud architect with 10 years of experience designing
enterprise-scale distributed systems on GCP. You specialize in Vertex AI, BigQuery,
and Cloud Spanner. When asked about architecture, you consider: scalability, cost,
reliability, security, and operational complexity. You cite specific GCP services
and their limitations.
"""

# Pedagogical role
teacher_system = """
You are an expert at explaining complex technical concepts to beginners.
You use analogies from everyday life. You check understanding by asking
a simple follow-up question at the end of each explanation.
You never use jargon without defining it first.
"""

# Reviewer role with specific constraints
reviewer_system = """
You are a strict code reviewer who follows Google's Python Style Guide.
Flag issues in these categories: correctness, security, performance, readability.
For each issue: state category, line reference, problem, and recommended fix.
Do not praise — only flag issues. If no issues found, respond with "LGTM".
"""

# Force specific structure with format specification
format_prompt = """
Analyze the following customer review. Respond using EXACTLY this format:

SUMMARY: [1-2 sentence summary]
SENTIMENT: [POSITIVE / NEGATIVE / NEUTRAL / MIXED]
SCORE: [1-10]
KEY_ISSUES: [comma-separated list, or "none"]
RECOMMENDED_ACTION: [one action for the team]

Review: {review}
"""

# Markdown output
markdown_prompt = """
Create a technical comparison. Format as markdown with:
- H2 header for each technology
- Bullet points for pros and cons
- A comparison table at the end with columns: Feature | Tech A | Tech B

Keep the table under 8 rows. Use checkmarks (✓) and X marks for binary features.
"""

# Prefill the assistant turn to start output in a specific format
response = client.messages.create(
    model="claude-3-5-sonnet@20241022",
    max_tokens=512,
    messages=[
        {"role": "user", "content": "List 3 GCP regions as a JSON array."},
        {"role": "assistant", "content": '["'}   # Force JSON array start
    ]
)
# Response continues from the prefill — guaranteed JSON array format
raw_response = '["' + response.content[0].text
regions = json.loads(raw_response)

# Prefill for SQL — force SELECT keyword
response = client.messages.create(
    model="claude-3-5-sonnet@20241022",
    max_tokens=512,
    messages=[
        {"role": "user", "content": "Write a BigQuery SQL to count rows in dataset.table"},
        {"role": "assistant", "content": "SELECT"}  # Force SELECT start
    ]
)

from anthropic import AnthropicVertex
import json

client = AnthropicVertex(region="us-east5", project_id="my-gcp-project")

tools = [
    {
        "name": "get_weather",
        "description": "Get current weather conditions for a specified city. Returns temperature, humidity, and conditions.",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "City name (e.g., 'San Francisco', 'London')"
                },
                "units": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Temperature units. Default: celsius",
                    "default": "celsius"
                }
            },
            "required": ["city"]
        }
    },
    {
        "name": "search_database",
        "description": "Search the internal product database for matching items. Use for product lookups, inventory checks, and pricing.",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "Search query string"
                },
                "category": {
                    "type": "string",
                    "enum": ["electronics", "clothing", "food", "all"],
                    "description": "Product category to search within"
                },
                "max_results": {
                    "type": "integer",
                    "description": "Maximum number of results (1-20)",
                    "minimum": 1,
                    "maximum": 20,
                    "default": 5
                }
            },
            "required": ["query"]
        }
    }
]

import json
from anthropic import AnthropicVertex

client = AnthropicVertex(region="us-east5", project_id="my-gcp-project")

# Tool definitions
tools = [
    {
        "name": "get_stock_price",
        "description": "Get the current stock price for a given ticker symbol. Returns price in USD.",
        "input_schema": {
            "type": "object",
            "properties": {
                "ticker": {
                    "type": "string",
                    "description": "Stock ticker symbol (e.g. GOOG, AAPL, MSFT)"
                }
            },
            "required": ["ticker"]
        }
    },
    {
        "name": "calculate_portfolio_value",
        "description": "Calculate total value of a stock portfolio given tickers and share counts.",
        "input_schema": {
            "type": "object",
            "properties": {
                "holdings": {
                    "type": "array",
                    "description": "List of holdings with ticker and shares",
                    "items": {
                        "type": "object",
                        "properties": {
                            "ticker": {"type": "string"},
                            "shares": {"type": "number"}
                        },
                        "required": ["ticker", "shares"]
                    }
                }
            },
            "required": ["holdings"]
        }
    }
]

# Tool implementation functions
def get_stock_price(ticker: str) -> dict:
    """Simulated stock price lookup."""
    prices = {"GOOG": 175.20, "AAPL": 189.50, "MSFT": 415.30, "AMZN": 195.00}
    if ticker.upper() in prices:
        return {"ticker": ticker.upper(), "price": prices[ticker.upper()], "currency": "USD"}
    return {"error": f"Unknown ticker: {ticker}"}

def calculate_portfolio_value(holdings: list) -> dict:
    """Calculate total portfolio value."""
    total = 0.0
    breakdown = []
    for holding in holdings:
        price_data = get_stock_price(holding["ticker"])
        if "error" in price_data:
            return price_data
        value = price_data["price"] * holding["shares"]
        total += value
        breakdown.append({
            "ticker": holding["ticker"],
            "shares": holding["shares"],
            "price": price_data["price"],
            "value": value
        })
    return {"total_value": total, "breakdown": breakdown, "currency": "USD"}

# Dispatch table
TOOL_FUNCTIONS = {
    "get_stock_price": get_stock_price,
    "calculate_portfolio_value": calculate_portfolio_value
}

def execute_tool(name: str, inputs: dict) -> str:
    """Execute a tool and return result as string."""
    if name not in TOOL_FUNCTIONS:
        return json.dumps({"error": f"Unknown tool: {name}"})
    try:
        result = TOOL_FUNCTIONS[name](**inputs)
        return json.dumps(result)
    except Exception as e:
        return json.dumps({"error": str(e)})

def run_agent(user_message: str) -> str:
    """Run the full tool-use agent loop."""
    messages = [{"role": "user", "content": user_message}]
    max_iterations = 10

    for iteration in range(max_iterations):
        response = client.messages.create(
            model="claude-3-5-sonnet@20241022",
            max_tokens=2048,
            tools=tools,
            messages=messages
        )

        print(f"[Iteration {iteration+1}] Stop reason: {response.stop_reason}")

        # Task complete — return final text response
        if response.stop_reason == "end_turn":
            for block in response.content:
                if hasattr(block, "text"):
                    return block.text
            return "[No text response]"

        # Handle tool use
        if response.stop_reason == "tool_use":
            # Append Claude's turn (includes tool_use blocks)
            messages.append({"role": "assistant", "content": response.content})

            # Execute all tool calls (Claude may request multiple in parallel)
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    print(f"  Calling tool: {block.name}({block.input})")
                    result = execute_tool(block.name, block.input)
                    print(f"  Result: {result}")
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": result
                    })

            # Append tool results and continue
            messages.append({"role": "user", "content": tool_results})

        else:
            # Unexpected stop reason
            break

    return "Max iterations reached without completing task."

# Test the agent
result = run_agent("What is the total value of a portfolio with 100 shares of Google and 50 shares of Apple?")
print(f"\nFinal answer: {result}")

# Default — Claude decides whether and which tool to use
response = client.messages.create(
    model="claude-3-5-sonnet@20241022",
    max_tokens=1024,
    tools=tools,
    tool_choice={"type": "auto"},  # Default behavior
    messages=messages
)

# Force Claude to use at least one tool
response = client.messages.create(
    model="claude-3-5-sonnet@20241022",
    max_tokens=1024,
    tools=tools,
    tool_choice={"type": "any"},  # Must call a tool
    messages=messages
)

# Force a specific tool
response = client.messages.create(
    model="claude-3-5-sonnet@20241022",
    max_tokens=1024,
    tools=tools,
    tool_choice={"type": "tool", "name": "get_stock_price"},
    messages=messages
)

# Disable all tool use
response = client.messages.create(
    model="claude-3-5-sonnet@20241022",
    max_tokens=1024,
    tools=tools,
    tool_choice={"type": "none"},  # No tools, text only
    messages=messages
)

# Claude's response content when calling multiple tools:
# [
#   ToolUseBlock(id="toolu_01", name="get_weather", input={"city": "London"}),
#   ToolUseBlock(id="toolu_02", name="get_weather", input={"city": "Tokyo"}),
#   ToolUseBlock(id="toolu_03", name="get_weather", input={"city": "Sydney"})
# ]

# You must provide ALL tool results before Claude can continue:
tool_results = [
    {"type": "tool_result", "tool_use_id": "toolu_01", "content": '{"city": "London", "temp": 15}'},
    {"type": "tool_result", "tool_use_id": "toolu_02", "content": '{"city": "Tokyo", "temp": 22}'},
    {"type": "tool_result", "tool_use_id": "toolu_03", "content": '{"city": "Sydney", "temp": 28}'}
]
messages.append({"role": "user", "content": tool_results})

bash_tool = {
    "name": "bash",
    "description": "Execute shell commands and return stdout/stderr",
    "input_schema": {
        "type": "object",
        "properties": {
            "command": {
                "type": "string",
                "description": "Shell command to execute"
            }
        },
        "required": ["command"]
    }
}

text_editor_tool = {
    "name": "str_replace_editor",
    "description": "View, create, and edit files",
    "input_schema": {
        "type": "object",
        "properties": {
            "command": {
                "type": "string",
                "enum": ["view", "create", "str_replace", "insert", "undo_edit"]
            },
            "path": {"type": "string"},
            "file_text": {"type": "string"},
            "old_str": {"type": "string"},
            "new_str": {"type": "string"},
            "insert_line": {"type": "integer"},
            "new_str_after_insert": {"type": "string"}
        },
        "required": ["command", "path"]
    }
}

web_search_tool = {
    "name": "web_search",
    "description": "Search the web for current information. Use when you need recent data, news, or facts not in your training data.",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "Search query"
            }
        },
        "required": ["query"]
    }
}

def execute_tool_safe(name: str, inputs: dict) -> str:
    """Execute tool with error handling — return error as JSON string, not exception."""
    try:
        if name == "get_stock_price":
            result = get_stock_price(**inputs)
        elif name == "calculate_portfolio_value":
            result = calculate_portfolio_value(**inputs)
        else:
            result = {"error": f"Unknown tool: {name}"}
        return json.dumps(result)
    except KeyError as e:
        return json.dumps({"error": f"Missing required parameter: {e}"})
    except ValueError as e:
        return json.dumps({"error": f"Invalid parameter value: {e}"})
    except Exception as e:
        return json.dumps({"error": f"Tool execution failed: {str(e)}"})

# Tool error response pattern — Claude will acknowledge the error and may retry or explain
tool_error_result = {
    "type": "tool_result",
    "tool_use_id": "toolu_01",
    "content": '{"error": "Stock price service unavailable. Please try again."}',
    "is_error": True  # Optional flag to mark as error result
}

from typing import List

def chunk_fixed_size(text: str, chunk_size: int = 800, overlap: int = 100) -> List[str]:
    """Fixed-size chunking with overlap to avoid losing context at boundaries."""
    words = text.split()
    chunks = []
    start = 0
    while start < len(words):
        end = start + chunk_size
        chunk = " ".join(words[start:end])
        chunks.append(chunk)
        start = end - overlap  # overlap to preserve context
    return chunks

def chunk_by_paragraph(text: str, max_words: int = 1000) -> List[str]:
    """Split at paragraph boundaries — preserves natural structure."""
    paragraphs = text.split("\n\n")
    chunks = []
    current_chunk = []
    current_count = 0

    for para in paragraphs:
        words = para.split()
        if current_count + len(words) > max_words and current_chunk:
            chunks.append("\n\n".join(current_chunk))
            current_chunk = [para]
            current_count = len(words)
        else:
            current_chunk.append(para)
            current_count += len(words)

    if current_chunk:
        chunks.append("\n\n".join(current_chunk))
    return chunks

def chunk_by_sections(text: str) -> List[dict]:
    """Chunk by markdown headers — preserves document structure."""
    import re
    sections = re.split(r'\n(?=#{1,3} )', text)
    chunks = []
    for section in sections:
        if section.strip():
            title_match = re.match(r'(#{1,3})\s+(.+)', section)
            title = title_match.group(2) if title_match else "Section"
            chunks.append({"title": title, "content": section.strip()})
    return chunks

import vertexai
from vertexai.language_models import TextEmbeddingModel, TextEmbeddingInput

# Initialize Vertex AI
vertexai.init(project="my-gcp-project", location="us-central1")

# Load embedding model
embedding_model = TextEmbeddingModel.from_pretrained("text-embedding-004")

def embed_text(text: str) -> List[float]:
    """Embed a single text string."""
    embeddings = embedding_model.get_embeddings([text])
    return embeddings[0].values  # 768-dimensional float vector

def embed_batch(texts: List[str], batch_size: int = 250) -> List[List[float]]:
    """Embed multiple texts with batching."""
    all_embeddings = []
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        embeddings = embedding_model.get_embeddings(batch)
        all_embeddings.extend([e.values for e in embeddings])
    return all_embeddings

# Task-specific embeddings (text-embedding-004 supports task types)
def embed_for_retrieval(query: str) -> List[float]:
    """Embed a query optimized for retrieval tasks."""
    inputs = [TextEmbeddingInput(query, task_type="RETRIEVAL_QUERY")]
    embeddings = embedding_model.get_embeddings(inputs)
    return embeddings[0].values

def embed_document_for_indexing(doc: str) -> List[float]:
    """Embed a document optimized for storage in vector index."""
    inputs = [TextEmbeddingInput(doc, task_type="RETRIEVAL_DOCUMENT")]
    embeddings = embedding_model.get_embeddings(inputs)
    return embeddings[0].values

from google.cloud import aiplatform

# Initialize
aiplatform.init(project="my-gcp-project", location="us-central1")

# Create an index (one-time setup — can take 30-60 minutes)
my_index = aiplatform.MatchingEngineIndex.create_tree_ah_index(
    display_name="rag-document-index",
    dimensions=768,
    approximate_neighbors_count=100,
    distance_measure_type="COSINE_DISTANCE",
    index_update_method="STREAM_UPDATE"  # or BATCH_UPDATE
)

# Deploy index to endpoint
my_index_endpoint = aiplatform.MatchingEngineIndexEndpoint.create(
    display_name="rag-index-endpoint",
    public_endpoint_enabled=True
)
my_index_endpoint.deploy_index(
    index=my_index,
    deployed_index_id="rag_deployed_index"
)

# Upsert vectors (add documents to index)
my_index.upsert_datapoints(
    datapoints=[
        aiplatform.MatchingEngineIndex.Datapoint(
            datapoint_id=str(chunk_id),
            feature_vector=embedding_vector,  # list of 768 floats
            restricts=[],                      # optional filtering metadata
            crowding_tag=None
        )
        for chunk_id, embedding_vector in chunk_embeddings.items()
    ]
)

# Query the index at runtime
def vector_search(query: str, top_k: int = 20) -> List[dict]:
    query_embedding = embed_for_retrieval(query)
    response = my_index_endpoint.find_neighbors(
        deployed_index_id="rag_deployed_index",
        queries=[query_embedding],
        num_neighbors=top_k
    )
    neighbors = response[0]  # First query's results
    return [
        {"id": n.id, "distance": n.distance}
        for n in neighbors
    ]

from rank_bm25 import BM25Okapi
import nltk

class BM25Index:
    def __init__(self):
        self.corpus = []
        self.chunk_ids = []
        self.bm25 = None

    def add_documents(self, chunks: List[dict]):
        """Index a list of chunks with {id, text}."""
        for chunk in chunks:
            tokens = self._tokenize(chunk["text"])
            self.corpus.append(tokens)
            self.chunk_ids.append(chunk["id"])
        self.bm25 = BM25Okapi(self.corpus)

    def _tokenize(self, text: str) -> List[str]:
        return text.lower().split()

    def search(self, query: str, top_k: int = 20) -> List[dict]:
        tokens = self._tokenize(query)
        scores = self.bm25.get_scores(tokens)
        top_indices = sorted(range(len(scores)), key=lambda i: scores[i], reverse=True)[:top_k]
        return [
            {"id": self.chunk_ids[i], "score": scores[i]}
            for i in top_indices if scores[i] > 0
        ]

def reciprocal_rank_fusion(
    *result_lists: List[dict],
    k: int = 60,
    id_field: str = "id"
) -> List[dict]:
    """Combine multiple ranked result lists using RRF."""
    scores = {}
    for results in result_lists:
        for rank, result in enumerate(results):
            doc_id = result[id_field]
            if doc_id not in scores:
                scores[doc_id] = 0
            scores[doc_id] += 1 / (k + rank + 1)

    sorted_ids = sorted(scores.items(), key=lambda x: x[1], reverse=True)
    return [{"id": doc_id, "rrf_score": score} for doc_id, score in sorted_ids]

def hybrid_search(query: str, top_k: int = 10) -> List[dict]:
    """Combine vector and BM25 search with RRF."""
    vector_results = vector_search(query, top_k=50)   # More candidates
    bm25_results = bm25_index.search(query, top_k=50)

    combined = reciprocal_rank_fusion(vector_results, bm25_results)
    return combined[:top_k]

def generate_chunk_context(document_summary: str, chunk: str) -> str:
    """Generate a contextual description of where this chunk fits in the document."""
    response = client.messages.create(
        model="claude-3-5-haiku@20241022",  # Use fast model for indexing
        max_tokens=200,
        messages=[{
            "role": "user",
            "content": f"""<document_summary>
{document_summary}
</document_summary>

<chunk>
{chunk}
</chunk>

Write a 2-3 sentence context that explains what this chunk is about, which section it belongs to, and what broader topic it covers. This context will be prepended to the chunk for retrieval purposes."""
        }]
    )
    context = response.content[0].text
    return f"{context}\n\n{chunk}"  # Prepend context to chunk

# Index with contextual enrichment
def index_document_with_context(document: dict, chunks: List[str]):
    doc_summary = summarize_document(document["full_text"])
    enriched_chunks = []
    for chunk in chunks:
        enriched = generate_chunk_context(doc_summary, chunk)
        enriched_chunks.append({
            "id": generate_id(),
            "text": enriched,
            "original_chunk": chunk,
            "source": document["title"]
        })
    # Embed enriched text, store originals for retrieval
    return enriched_chunks