{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "bedrock:InvokeModel",
        "bedrock:InvokeModelWithResponseStream",
        "bedrock:CreateModelInvocationJob",
        "bedrock:GetModelInvocationJob",
        "bedrock:ListFoundationModels"
      ],
      "Resource": "*"
    }
  ]
}

import boto3
import json

# Option 1: Explicit credentials (dev only — never in production code)
client = boto3.client(
    'bedrock-runtime',
    region_name='us-east-1',
    aws_access_key_id='AKIA...',
    aws_secret_access_key='...'
)

# Option 2: Environment variables (recommended for dev)
# AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_DEFAULT_REGION
client = boto3.client('bedrock-runtime', region_name='us-east-1')

# Option 3: IAM role (recommended for production / EC2 / Lambda)
# boto3 automatically picks up role credentials
client = boto3.client('bedrock-runtime', region_name='us-east-1')

# Option 4: Named profile from ~/.aws/credentials
session = boto3.Session(profile_name='my-bedrock-profile')
client = session.client('bedrock-runtime', region_name='us-east-1')

body = {
    "anthropic_version": "bedrock-2023-05-31",  # REQUIRED — do not omit
    "max_tokens": 1024,                           # REQUIRED
    "messages": [                                 # REQUIRED
        {"role": "user", "content": "Hello"}
    ],
    # Optional fields:
    "system": "You are a helpful assistant.",
    "temperature": 0.7,
    "top_p": 0.9,
    "top_k": 250,
    "stop_sequences": ["###"]
}

response = client.invoke_model(
    modelId='anthropic.claude-3-5-sonnet-20241022-v2:0',
    contentType='application/json',
    accept='application/json',
    body=json.dumps(body)   # Must be bytes or string
)

response = client.invoke_model(...)

# response is a dict with HTTP metadata + 'body' StreamingBody
raw = response['body'].read()          # Read all bytes
result = json.loads(raw)               # Parse JSON

# result structure:
# {
#   "id": "msg_01...",
#   "type": "message",
#   "role": "assistant",
#   "content": [{"type": "text", "text": "..."}],
#   "model": "claude-3-5-sonnet-20241022",
#   "stop_reason": "end_turn",
#   "stop_sequence": null,
#   "usage": {"input_tokens": 25, "output_tokens": 142}
# }

text = result['content'][0]['text']
input_tokens = result['usage']['input_tokens']
output_tokens = result['usage']['output_tokens']

import boto3
import json

client = boto3.client('bedrock-runtime', region_name='us-east-1')
MODEL_ID = 'anthropic.claude-3-5-sonnet-20241022-v2:0'

def invoke_claude(prompt, system=None, max_tokens=1024, temperature=1.0):
    body = {
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": max_tokens,
        "messages": [{"role": "user", "content": prompt}]
    }
    if system:
        body["system"] = system
    if temperature != 1.0:
        body["temperature"] = temperature

    response = client.invoke_model(
        modelId=MODEL_ID,
        contentType='application/json',
        accept='application/json',
        body=json.dumps(body)
    )

    result = json.loads(response['body'].read())
    return result['content'][0]['text'], result['usage']

text, usage = invoke_claude("What is the capital of France?")
print(text)
print(f"Tokens used: {usage['input_tokens']} in, {usage['output_tokens']} out")

import boto3, json

client = boto3.client('bedrock-runtime', region_name='us-east-1')
MODEL_ID = 'anthropic.claude-3-5-sonnet-20241022-v2:0'

class BedrockChatbot:
    def __init__(self, system_prompt=None):
        self.system = system_prompt
        self.history = []     # List of {"role": ..., "content": ...}
        self.total_tokens = {"input": 0, "output": 0}

    def chat(self, user_message, max_tokens=2048):
        self.history.append({"role": "user", "content": user_message})

        body = {
            "anthropic_version": "bedrock-2023-05-31",
            "max_tokens": max_tokens,
            "messages": self.history
        }
        if self.system:
            body["system"] = self.system

        response = client.invoke_model(
            modelId=MODEL_ID,
            contentType='application/json',
            accept='application/json',
            body=json.dumps(body)
        )

        result = json.loads(response['body'].read())
        assistant_text = result['content'][0]['text']

        self.history.append({"role": "assistant", "content": assistant_text})
        self.total_tokens["input"] += result['usage']['input_tokens']
        self.total_tokens["output"] += result['usage']['output_tokens']

        return assistant_text

    def reset(self):
        self.history = []

# REPL chatbot
bot = BedrockChatbot(system_prompt="You are an expert Python tutor.")
print("Chatbot ready. Type 'quit' to exit, 'reset' to clear history.")
while True:
    user_input = input("You: ").strip()
    if user_input.lower() == 'quit':
        break
    if user_input.lower() == 'reset':
        bot.reset()
        print("History cleared.")
        continue
    response = bot.chat(user_input)
    print(f"Claude: {response}\n")
print(f"Total tokens: {bot.total_tokens}")

# System prompts configure the model's persona, constraints, and behavior
# They are separate from the messages array — top-level "system" key

body = {
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 1024,
    "system": """You are a senior AWS solutions architect.
Always recommend AWS-native services where possible.
Format responses with clear headings and bullet points.
If asked about pricing, always say to check the AWS Pricing Calculator.""",
    "messages": [
        {"role": "user", "content": "How should I deploy a Python API?"}
    ]
}

# temperature: 0.0 to 1.0 (some models accept up to 2.0 via direct API, Bedrock caps at 1.0)
# 0.0 = deterministic, always same output (good for structured tasks)
# 1.0 = maximum diversity (good for creative tasks)

# Deterministic extraction
body_extract = {
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 512,
    "temperature": 0.0,    # Fully deterministic
    "messages": [{"role": "user", "content": "Extract the date from: Meeting on Jan 15 2024"}]
}

# Creative writing
body_creative = {
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 1024,
    "temperature": 1.0,    # Full creativity
    "messages": [{"role": "user", "content": "Write a haiku about cloud computing."}]
}

# top_p: nucleus sampling — consider top P% of probability mass (alternative to temperature)
# top_k: only consider top K tokens at each step
# Do not set both temperature and top_p — choose one

import boto3, json

client = boto3.client('bedrock-runtime', region_name='us-east-1')
MODEL_ID = 'anthropic.claude-3-5-sonnet-20241022-v2:0'

def stream_response(prompt, system=None, max_tokens=2048):
    body = {
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": max_tokens,
        "messages": [{"role": "user", "content": prompt}]
    }
    if system:
        body["system"] = system

    response = client.invoke_model_with_response_stream(
        modelId=MODEL_ID,
        contentType='application/json',
        accept='application/json',
        body=json.dumps(body)
    )

    full_text = ""
    input_tokens = 0
    output_tokens = 0

    for event in response['body']:
        chunk_bytes = event['chunk']['bytes']
        chunk = json.loads(chunk_bytes.decode('utf-8'))

        event_type = chunk.get('type', '')

        if event_type == 'content_block_delta':
            # Text delta — print as it arrives
            delta_text = chunk['delta'].get('text', '')
            print(delta_text, end='', flush=True)
            full_text += delta_text

        elif event_type == 'message_delta':
            # Final stats
            output_tokens = chunk.get('usage', {}).get('output_tokens', 0)

        elif event_type == 'message_start':
            # Initial metadata including input token count
            input_tokens = chunk.get('message', {}).get('usage', {}).get('input_tokens', 0)

        elif event_type == 'message_stop':
            # Stream complete
            pass

    print()  # newline after stream
    return full_text, {"input_tokens": input_tokens, "output_tokens": output_tokens}

# Usage
text, usage = stream_response("Explain quantum entanglement in simple terms.")
print(f"\nUsage: {usage}")

# max_tokens: hard cap on output length (required field)
# stop_sequences: list of strings that end generation when encountered
# top_p: cumulative probability for nucleus sampling
# top_k: limit token selection to top K candidates

body = {
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 2048,
    "stop_sequences": ["</answer>", "Human:", "###"],
    "top_p": 0.95,
    "messages": [
        {"role": "user", "content": "Answer this: What is 2+2? Wrap in <answer> tags."}
    ]
}

# The model stops when it would generate a stop sequence
# result['stop_reason'] will be "stop_sequence" if that triggered the stop
# result['stop_sequence'] gives which sequence triggered it

import json

def extract_structured_data(text, schema_description):
    """Extract structured data from unstructured text using Claude."""
    prompt = f"""Extract the following information from the text and return as JSON.

Schema: {schema_description}

Text:
{text}

Return ONLY valid JSON, no explanation."""

    body = {
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": 1024,
        "temperature": 0.0,   # Deterministic for extraction
        "messages": [{"role": "user", "content": prompt}]
    }

    response = client.invoke_model(
        modelId=MODEL_ID,
        contentType='application/json',
        accept='application/json',
        body=json.dumps(body)
    )

    result = json.loads(response['body'].read())
    raw_text = result['content'][0]['text'].strip()

    # Strip markdown code fences if present
    if raw_text.startswith('```'):
        raw_text = raw_text.split('\n', 1)[1].rsplit('```', 1)[0].strip()

    return json.loads(raw_text)

# Example usage
invoice_text = """
Invoice #1234 from Acme Corp, dated March 15 2024.
Total amount: $2,450.00. Payment due April 15 2024.
Contact: billing@acme.com
"""

schema = '{"invoice_number": "string", "vendor": "string", "amount": "number", "due_date": "string"}'
data = extract_structured_data(invoice_text, schema)
print(data)
# {'invoice_number': '1234', 'vendor': 'Acme Corp', 'amount': 2450.00, 'due_date': '2024-04-15'}

# Standard model ID — fixed to one region
MODEL_ID = 'anthropic.claude-3-5-sonnet-20241022-v2:0'

# Cross-region inference profile — routes across AZs within geography
# US profiles:
CROSS_REGION_US = 'us.anthropic.claude-3-5-sonnet-20241022-v2:0'

# EU profiles:
CROSS_REGION_EU = 'eu.anthropic.claude-3-5-sonnet-20241022-v2:0'

# When using cross-region, the client region still determines the entry point
client = boto3.client('bedrock-runtime', region_name='us-east-1')
# Then use CROSS_REGION_US as modelId — Bedrock routes intelligently

import boto3
import json
from botocore.exceptions import ClientError
import time

def invoke_with_retry(client, model_id, body, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = client.invoke_model(
                modelId=model_id,
                contentType='application/json',
                accept='application/json',
                body=json.dumps(body)
            )
            return json.loads(response['body'].read())

        except ClientError as e:
            error_code = e.response['Error']['Code']

            if error_code == 'ThrottlingException':
                wait = (2 ** attempt) + 1  # Exponential backoff
                print(f"Throttled. Waiting {wait}s before retry {attempt+1}/{max_retries}")
                time.sleep(wait)
                continue

            elif error_code == 'ValidationException':
                raise ValueError(f"Invalid request: {e.response['Error']['Message']}")

            elif error_code == 'AccessDeniedException':
                raise PermissionError("Check IAM permissions and model access in Bedrock console")

            elif error_code == 'ModelNotReadyException':
                raise RuntimeError("Model not available — check Bedrock console model access status")

            else:
                raise

    raise RuntimeError(f"Max retries ({max_retries}) exceeded")

def generate_eval_dataset(task_description, num_examples=20):
    """Use Claude to generate diverse test cases."""
    prompt = f"""Generate {num_examples} diverse test cases for this task: {task_description}

For each test case, provide:
1. An input
2. The expected output
3. The difficulty level (easy/medium/hard)

Format as JSON array: [{{"input": "...", "expected": "...", "difficulty": "..."}}]
Return ONLY the JSON array."""

    body = {
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": 4096,
        "temperature": 1.0,   # Diversity for generation
        "messages": [{"role": "user", "content": prompt}]
    }
    response = client.invoke_model(
        modelId=MODEL_ID,
        contentType='application/json',
        accept='application/json',
        body=json.dumps(body)
    )
    result = json.loads(response['body'].read())
    return json.loads(result['content'][0]['text'])

GRADER_MODEL = 'anthropic.claude-3-haiku-20240307-v1:0'  # Cheap for grading

def model_grade(output, expected, criterion, scale=5):
    """Use Claude to grade an output. Returns score 1-scale."""
    grading_prompt = f"""You are an impartial grader. Evaluate the output against the criterion.

Criterion: {criterion}
Expected: {expected}
Actual Output: {output}

Score the output from 1 to {scale}:
1 = Completely wrong
{scale} = Perfect

Return ONLY a single integer score."""

    body = {
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": 10,
        "temperature": 0.0,
        "messages": [{"role": "user", "content": grading_prompt}]
    }
    response = client.invoke_model(
        modelId=GRADER_MODEL,
        contentType='application/json',
        accept='application/json',
        body=json.dumps(body)
    )
    result = json.loads(response['body'].read())
    try:
        return int(result['content'][0]['text'].strip())
    except ValueError:
        return 0   # Failed to parse score

import concurrent.futures
import json
import time
from datetime import datetime

def run_evaluation(dataset, prompt_template, model_id, grader_fn, max_workers=5):
    """Run full evaluation suite with parallel grading."""

    def evaluate_single(example):
        # Format prompt with template
        prompt = prompt_template.format(input=example['input'])
        body = {
            "anthropic_version": "bedrock-2023-05-31",
            "max_tokens": 512,
            "temperature": 0.0,
            "messages": [{"role": "user", "content": prompt}]
        }
        try:
            response = client.invoke_model(
                modelId=model_id,
                contentType='application/json',
                accept='application/json',
                body=json.dumps(body)
            )
            result = json.loads(response['body'].read())
            output = result['content'][0]['text'].strip()
            score = grader_fn(output, example['expected'])
            return {
                "input": example['input'],
                "expected": example['expected'],
                "output": output,
                "score": score,
                "tokens": result['usage']
            }
        except Exception as e:
            return {"input": example['input'], "error": str(e), "score": 0}

    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
        results = list(executor.map(evaluate_single, dataset))

    # Compute metrics
    scores = [r['score'] for r in results if 'score' in r]
    total_tokens = sum(
        r.get('tokens', {}).get('input_tokens', 0) + r.get('tokens', {}).get('output_tokens', 0)
        for r in results
    )

    summary = {
        "timestamp": datetime.now().isoformat(),
        "model_id": model_id,
        "n_examples": len(dataset),
        "accuracy": sum(1 for s in scores if s >= 1) / len(scores),
        "avg_score": sum(scores) / len(scores) if scores else 0,
        "total_tokens": total_tokens,
        "failures": [r for r in results if 'error' in r]
    }

    return results, summary

<instructions>
Classify the customer review as POSITIVE, NEGATIVE, or NEUTRAL.
Rules:
1. If the review mentions both pros and cons equally, use NEUTRAL
2. Ignore overall star rating — focus only on the text sentiment
3. Respond with ONLY the classification word, nothing else
</instructions>

<examples>
<example>
<input>Amazing product! Shipped fast and works perfectly.</input>
<output>POSITIVE</output>
</example>
<example>
<input>The quality is decent but the price is way too high for what you get.</input>
<output>NEUTRAL</output>
</example>
<example>
<input>Terrible. Broke after 2 days. Don't buy this.</input>
<output>NEGATIVE</output>
</example>
</examples>

<review>
{customer_review}
</review>

# Few-shot improves consistency for pattern-following tasks
# Include 2-5 examples that exactly match desired output format

few_shot_prompt = """Convert natural language to SQL.

Input: Get all users who signed up after January 2024
SQL: SELECT * FROM users WHERE created_at > '2024-01-01';

Input: Find the top 10 products by revenue
SQL: SELECT product_id, SUM(revenue) as total FROM orders GROUP BY product_id ORDER BY total DESC LIMIT 10;

Input: {user_query}
SQL:"""

# Standard CoT: ask model to think before answering
cot_prompt = """Solve this step by step, then give the final answer.

Problem: {problem}

Show your reasoning in <thinking> tags, then the answer in <answer> tags."""

# Zero-shot CoT trigger phrases:
# - "Let's think step by step."
# - "Work through this carefully."
# - "Think before answering."

# Structured CoT with stop sequence
body = {
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 2048,
    "stop_sequences": ["</answer>"],   # Stop after getting the answer
    "messages": [{"role": "user", "content": cot_prompt.format(problem="...")}]
}

system_roles = {
    "code_reviewer": "You are a senior software engineer with 15 years of experience. Review code for bugs, security issues, and style. Be direct and specific.",
    "legal_analyst": "You are a paralegal assistant. Identify legal issues in contracts. Always note that this is not legal advice and recommend consulting a lawyer.",
    "data_scientist": "You are a senior data scientist. Analyze data, suggest statistical approaches, and write production-quality Python code using pandas, numpy, and scikit-learn.",
}

# Force JSON output
json_prompt = """Extract entity information from the text.
Return a JSON object with these keys: name, type, description.
Return ONLY the JSON object, no other text.

Text: {text}"""

# Force specific structure with prefill
body = {
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 512,
    "messages": [
        {"role": "user", "content": json_prompt},
        {"role": "assistant", "content": "{"}  # Prefill forces JSON start
    ]
}

tools = [
    {
        "name": "get_weather",                    # Snake_case, clear verb+noun
        "description": """Get current weather for a city.
Returns temperature in specified unit and weather condition.
Use this when the user asks about current weather in any location.""",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "City name, e.g. 'New York' or 'London'"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Temperature unit. Default to celsius."
                }
            },
            "required": ["city"]   # unit is optional
        }
    },
    {
        "name": "search_database",
        "description": "Search the product database by keyword or SKU",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "Search term"},
                "limit": {
                    "type": "integer",
                    "description": "Max results to return",
                    "minimum": 1,
                    "maximum": 50,
                    "default": 10
                },
                "category": {
                    "type": "string",
                    "enum": ["electronics", "clothing", "books", "all"],
                    "default": "all"
                }
            },
            "required": ["query"]
        }
    }
]

def parse_tool_calls(response):
    """Extract tool calls from Claude's response content."""
    tool_calls = []
    text_blocks = []

    for block in response['content']:
        if block['type'] == 'tool_use':
            tool_calls.append({
                'id': block['id'],          # Must be preserved for tool_result
                'name': block['name'],
                'input': block['input']     # Dict matching tool's input_schema
            })
        elif block['type'] == 'text':
            text_blocks.append(block['text'])

    return tool_calls, text_blocks

def build_tool_results_message(tool_results_map):
    """Build the user message containing all tool results.
    tool_results_map: {tool_use_id: result_data}
    """
    content = []
    for tool_use_id, result in tool_results_map.items():
        content.append({
            "type": "tool_result",
            "tool_use_id": tool_use_id,         # Must match the tool_use block's id
            "content": json.dumps(result)        # String or list of content blocks
        })
    return {"role": "user", "content": content}

# Error in tool execution
def build_tool_error(tool_use_id, error_message):
    return {
        "type": "tool_result",
        "tool_use_id": tool_use_id,
        "content": f"Error: {error_message}",
        "is_error": True    # Signals to Claude that the tool failed
    }

import boto3, json

client = boto3.client('bedrock-runtime', region_name='us-east-1')
MODEL_ID = 'anthropic.claude-3-5-sonnet-20241022-v2:0'

# Define available tools
tools = [
    {
        "name": "get_stock_price",
        "description": "Get the current stock price for a ticker symbol",
        "input_schema": {
            "type": "object",
            "properties": {
                "ticker": {"type": "string", "description": "Stock ticker symbol, e.g. AAPL"}
            },
            "required": ["ticker"]
        }
    },
    {
        "name": "calculate",
        "description": "Evaluate a mathematical expression",
        "input_schema": {
            "type": "object",
            "properties": {
                "expression": {"type": "string", "description": "Math expression to evaluate"}
            },
            "required": ["expression"]
        }
    }
]

# Mock tool implementations
def get_stock_price(ticker):
    prices = {"AAPL": 182.50, "GOOGL": 141.80, "AMZN": 175.30}
    price = prices.get(ticker.upper())
    if price is None:
        return {"error": f"Unknown ticker: {ticker}"}
    return {"ticker": ticker, "price": price, "currency": "USD"}

def calculate(expression):
    try:
        # Use eval carefully — in production, use a safe math parser
        result = eval(expression, {"__builtins__": {}}, {"abs": abs, "round": round})
        return {"result": result}
    except Exception as e:
        return {"error": str(e)}

def dispatch_tool(name, tool_input):
    """Route tool call to implementation."""
    if name == "get_stock_price":
        return get_stock_price(**tool_input)
    elif name == "calculate":
        return calculate(**tool_input)
    else:
        return {"error": f"Unknown tool: {name}"}

def run_agent(user_message, max_iterations=10):
    """Run the tool use loop until end_turn."""
    messages = [{"role": "user", "content": user_message}]
    iteration = 0

    while iteration < max_iterations:
        iteration += 1

        body = {
            "anthropic_version": "bedrock-2023-05-31",
            "max_tokens": 4096,
            "tools": tools,
            "messages": messages
        }

        response = json.loads(client.invoke_model(
            modelId=MODEL_ID,
            contentType='application/json',
            accept='application/json',
            body=json.dumps(body)
        )['body'].read())

        stop_reason = response['stop_reason']

        # Always add assistant response to history
        messages.append({"role": "assistant", "content": response['content']})

        if stop_reason == 'end_turn':
            # Extract final text
            for block in response['content']:
                if block['type'] == 'text':
                    return block['text']
            return ""

        elif stop_reason == 'tool_use':
            # Execute all tool calls
            tool_results = []
            for block in response['content']:
                if block['type'] == 'tool_use':
                    print(f"  Calling tool: {block['name']}({block['input']})")
                    result = dispatch_tool(block['name'], block['input'])
                    print(f"  Result: {result}")
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block['id'],
                        "content": json.dumps(result)
                    })

            # Add tool results as user message
            messages.append({"role": "user", "content": tool_results})

        else:
            print(f"Unexpected stop_reason: {stop_reason}")
            break

    return "Max iterations reached"

# Test
result = run_agent("What is AAPL's current stock price? And what's 15% of that price?")
print(result)

# Auto (default): Claude decides when to call tools
body["tool_choice"] = {"type": "auto"}

# Any: Claude must call at least one tool
body["tool_choice"] = {"type": "any"}

# Force specific tool
body["tool_choice"] = {"type": "tool", "name": "get_weather"}

# Disable tools entirely (even if defined)
body["tool_choice"] = {"type": "none"}

# Claude may return MULTIPLE tool_use blocks in one response
# This means Claude wants to call multiple tools in parallel
# You must execute ALL of them and return ALL results before continuing

def handle_parallel_tools(response_content, dispatch_fn):
    """Handle multiple parallel tool calls."""
    tool_results = []

    # Collect all tool_use blocks
    tool_calls = [b for b in response_content if b['type'] == 'tool_use']

    if not tool_calls:
        return None

    # Execute all in parallel
    import concurrent.futures
    with concurrent.futures.ThreadPoolExecutor() as executor:
        futures = {
            executor.submit(dispatch_fn, tc['name'], tc['input']): tc['id']
            for tc in tool_calls
        }
        for future, tool_use_id in futures.items():
            result = future.result()
            tool_results.append({
                "type": "tool_result",
                "tool_use_id": tool_use_id,
                "content": json.dumps(result)
            })

    return {"role": "user", "content": tool_results}

# Using tools for structured extraction is more reliable than JSON parsing
# The tool_use block guarantees valid structure matching the schema

extraction_tool = {
    "name": "extract_invoice",
    "description": "Extract invoice data from the provided text",
    "input_schema": {
        "type": "object",
        "properties": {
            "invoice_number": {"type": "string"},
            "vendor_name": {"type": "string"},
            "total_amount": {"type": "number"},
            "due_date": {"type": "string", "format": "date"},
            "line_items": {
                "type": "array",
                "items": {
                    "type": "object",
                    "properties": {
                        "description": {"type": "string"},
                        "quantity": {"type": "number"},
                        "unit_price": {"type": "number"}
                    }
                }
            }
        },
        "required": ["invoice_number", "vendor_name", "total_amount"]
    }
}

body = {
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 1024,
    "tools": [extraction_tool],
    "tool_choice": {"type": "tool", "name": "extract_invoice"},  # Force it
    "messages": [{"role": "user", "content": f"Extract data from: {invoice_text}"}]
}

response = json.loads(client.invoke_model(
    modelId=MODEL_ID, contentType='application/json',
    accept='application/json', body=json.dumps(body)
)['body'].read())

# The extracted data is guaranteed to match the schema
extracted = response['content'][0]['input']

# For high-volume, non-time-sensitive workloads
# Input: S3 JSONL file (one request per line)
# Output: S3 JSONL file (one result per line, same order)

import boto3, json

bedrock = boto3.client('bedrock', region_name='us-east-1')

# Create batch job
job = bedrock.create_model_invocation_job(
    jobName='my-batch-job-001',
    modelId='anthropic.claude-3-haiku-20240307-v1:0',
    inputDataConfig={
        "s3InputDataConfig": {
            "s3Uri": "s3://my-bucket/batch-input/requests.jsonl",
            "s3InputFormat": "JSONL"
        }
    },
    outputDataConfig={
        "s3OutputDataConfig": {
            "s3Uri": "s3://my-bucket/batch-output/"
        }
    },
    roleArn="arn:aws:iam::123456789:role/BedrockBatchRole"
)

job_arn = job['jobArn']

# Poll for completion
import time
while True:
    status = bedrock.get_model_invocation_job(jobIdentifier=job_arn)
    state = status['status']
    if state == 'Completed':
        break
    elif state in ('Failed', 'Stopped'):
        raise RuntimeError(f"Batch job failed: {state}")
    print(f"Job status: {state}")
    time.sleep(30)

def chunk_text_recursive(text, max_chunk_size=500, overlap=50):
    """Recursive character splitting with overlap."""
    separators = ["\n\n", "\n", ". ", " ", ""]
    chunks = []

    def split(text, separators):
        if len(text) <= max_chunk_size:
            return [text]

        for sep in separators:
            if sep in text:
                parts = text.split(sep)
                current = ""
                result = []
                for part in parts:
                    candidate = current + sep + part if current else part
                    if len(candidate) <= max_chunk_size:
                        current = candidate
                    else:
                        if current:
                            result.append(current)
                        current = part
                if current:
                    result.append(current)
                return result
        return [text[:max_chunk_size]]

    raw_chunks = split(text, separators)

    # Add overlap
    for i, chunk in enumerate(raw_chunks):
        if i > 0 and overlap > 0:
            prev_end = raw_chunks[i-1][-overlap:]
            chunk = prev_end + " " + chunk
        chunks.append(chunk.strip())

    return chunks

import boto3, json
import numpy as np

bedrock_client = boto3.client('bedrock-runtime', region_name='us-east-1')

def embed_text(text, model_id='amazon.titan-embed-text-v2:0'):
    """Generate embedding vector for text using Amazon Titan."""
    body = {
        "inputText": text,
        "dimensions": 1024,      # 256, 512, or 1024 (Titan V2)
        "normalize": True        # Normalize to unit vector for cosine similarity
    }
    response = bedrock_client.invoke_model(
        modelId=model_id,
        contentType='application/json',
        accept='application/json',
        body=json.dumps(body)
    )
    result = json.loads(response['body'].read())
    return np.array(result['embedding'])

def embed_batch(texts, model_id='amazon.titan-embed-text-v2:0'):
    """Embed multiple texts (sequential for Titan — no batch endpoint)."""
    return [embed_text(t, model_id) for t in texts]

# Cohere Embed on Bedrock (better multilingual)
def embed_cohere(text, input_type='search_document'):
    body = {
        "texts": [text],
        "input_type": input_type,   # 'search_document' for indexing, 'search_query' for queries
        "truncate": "END"
    }
    response = bedrock_client.invoke_model(
        modelId='cohere.embed-multilingual-v3',
        contentType='application/json',
        accept='application/json',
        body=json.dumps(body)
    )
    return json.loads(response['body'].read())['embeddings'][0]

import numpy as np
from typing import List, Dict

class SimpleVectorStore:
    def __init__(self):
        self.chunks = []
        self.embeddings = []
        self.metadata = []

    def add(self, text: str, embedding: np.ndarray, metadata: Dict = None):
        self.chunks.append(text)
        self.embeddings.append(embedding)
        self.metadata.append(metadata or {})

    def search(self, query_embedding: np.ndarray, top_k: int = 5) -> List[Dict]:
        if not self.embeddings:
            return []

        # Cosine similarity
        matrix = np.array(self.embeddings)
        scores = matrix @ query_embedding  # Assumes normalized vectors
        top_indices = np.argsort(scores)[::-1][:top_k]

        return [
            {
                "text": self.chunks[i],
                "score": float(scores[i]),
                "metadata": self.metadata[i]
            }
            for i in top_indices
        ]

def build_rag_index(documents, chunk_size=500):
    """Index documents into vector store."""
    store = SimpleVectorStore()
    for doc in documents:
        chunks = chunk_text_recursive(doc['text'], chunk_size)
        for i, chunk in enumerate(chunks):
            embedding = embed_text(chunk)
            store.add(chunk, embedding, {
                "source": doc.get('title', 'unknown'),
                "chunk_index": i
            })
    return store

def rag_query(question, store, top_k=5):
    """Retrieve relevant chunks and generate answer."""
    # 1. Embed the question
    q_embedding = embed_text(question)

    # 2. Retrieve top-K chunks
    results = store.search(q_embedding, top_k=top_k)

    # 3. Build context
    context = "\n\n---\n\n".join([
        f"Source: {r['metadata'].get('source', 'unknown')}\n{r['text']}"
        for r in results
    ])

    # 4. Generate answer
    body = {
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": 1024,
        "system": "Answer questions based only on the provided context. If the answer is not in the context, say so.",
        "messages": [{
            "role": "user",
            "content": f"Context:\n{context}\n\nQuestion: {question}"
        }]
    }

    response = bedrock_client.invoke_model(
        modelId='anthropic.claude-3-5-sonnet-20241022-v2:0',
        contentType='application/json',
        accept='application/json',
        body=json.dumps(body)
    )
    result = json.loads(response['body'].read())
    return result['content'][0]['text'], results

# BM25 = Best Match 25 — probabilistic TF-IDF variant
# Great for exact keyword matches, product codes, names

# Install: pip install rank_bm25
from rank_bm25 import BM25Okapi
import re

def tokenize(text):
    return re.findall(r'\w+', text.lower())

class BM25Index:
    def __init__(self, documents):
        self.docs = documents
        tokenized = [tokenize(d['text']) for d in documents]
        self.bm25 = BM25Okapi(tokenized)

    def search(self, query, top_k=10):
        tokens = tokenize(query)
        scores = self.bm25.get_scores(tokens)
        top_indices = sorted(range(len(scores)), key=lambda i: scores[i], reverse=True)[:top_k]
        return [
            {"text": self.docs[i]['text'], "score": float(scores[i]), "metadata": self.docs[i].get('metadata', {})}
            for i in top_indices if scores[i] > 0
        ]

def reciprocal_rank_fusion(result_lists, k=60):
    """Merge multiple ranked result lists using RRF.
    k=60 is the standard constant — higher k = less weight to top ranks.
    """
    scores = {}  # doc_id -> RRF score

    for results in result_lists:
        for rank, result in enumerate(results):
            doc_id = result.get('id') or result['text'][:50]  # Use text prefix as id
            if doc_id not in scores:
                scores[doc_id] = {"score": 0.0, "data": result}
            scores[doc_id]["score"] += 1.0 / (k + rank + 1)

    return sorted(scores.values(), key=lambda x: x["score"], reverse=True)

def hybrid_search(query, vector_store, bm25_index, top_k=10, final_k=5):
    """Run vector + BM25 search and merge with RRF."""
    q_embedding = embed_text(query)

    vector_results = vector_store.search(q_embedding, top_k=top_k)
    bm25_results = bm25_index.search(query, top_k=top_k)

    # Add ID for merging
    for i, r in enumerate(vector_results):
        r['id'] = r['text'][:80]
    for i, r in enumerate(bm25_results):
        r['id'] = r['text'][:80]

    merged = reciprocal_rank_fusion([vector_results, bm25_results])
    return [m['data'] for m in merged[:final_k]]

def rerank_with_bedrock(query, documents, top_k=5):
    """Rerank retrieved documents using Amazon Bedrock Reranker."""
    bedrock_agent = boto3.client('bedrock-agent-runtime', region_name='us-east-1')

    response = bedrock_agent.rerank(
        rerankingConfiguration={
            "type": "BEDROCK_RERANKING_MODEL",
            "bedrockRerankingConfiguration": {
                "modelConfiguration": {
                    "modelArn": "arn:aws:bedrock:us-east-1::foundation-model/amazon.rerank-v1:0"
                },
                "numberOfResults": top_k
            }
        },
        sources=[
            {
                "type": "INLINE",
                "inlineDocumentSource": {
                    "type": "TEXT",
                    "textDocument": {"text": doc['text']}
                }
            }
            for doc in documents
        ],
        textSources=[{"type": "QUERY", "query": {"text": query}}]
    )

    return [
        {
            "text": documents[item['index']]['text'],
            "rerank_score": item['relevanceScore'],
            "original_rank": item['index']
        }
        for item in sorted(response['rerankingResults'], key=lambda x: x['relevanceScore'], reverse=True)
    ]

def add_chunk_context(chunk, full_document, model_id='anthropic.claude-3-haiku-20240307-v1:0'):
    """Prepend contextual summary to each chunk before embedding.
    Significantly improves retrieval accuracy by giving chunks document context.
    """
    prompt = f"""Here is a document:
<document>
{full_document[:3000]}  <!-- Truncate to avoid context overflow -->
</document>

Here is one chunk from this document:
<chunk>
{chunk}
</chunk>

Write a short 1-2 sentence context for this chunk that explains where it fits within the full document.
Return ONLY the context sentences, no preamble."""

    body = {
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": 100,
        "temperature": 0.0,
        "messages": [{"role": "user", "content": prompt}]
    }
    response = bedrock_client.invoke_model(
        modelId=model_id,
        contentType='application/json',
        accept='application/json',
        body=json.dumps(body)
    )
    context = json.loads(response['body'].read())['content'][0]['text']
    return f"{context}\n\n{chunk}"   # Prepend context to chunk

# Bedrock Knowledge Bases (Managed RAG)
bedrock_agent_runtime = boto3.client('bedrock-agent-runtime', region_name='us-east-1')

def kb_retrieve_and_generate(query, knowledge_base_id, model_arn):
    """Use Bedrock Knowledge Bases for fully managed RAG."""
    response = bedrock_agent_runtime.retrieve_and_generate(
        input={"text": query},
        retrieveAndGenerateConfiguration={
            "type": "KNOWLEDGE_BASE",
            "knowledgeBaseConfiguration": {
                "knowledgeBaseId": knowledge_base_id,
                "modelArn": model_arn,
                "retrievalConfiguration": {
                    "vectorSearchConfiguration": {"numberOfResults": 10}
                }
            }
        }
    )
    return {
        "answer": response['output']['text'],
        "citations": response.get('citations', [])
    }