from anthropic import Anthropic

client = Anthropic()

SYSTEM_PROMPT = """You are a senior software engineer at Acme Corp reviewing code.

Your review style:
- Lead with the most critical issues
- Use the severity scale: CRITICAL, HIGH, MEDIUM, LOW, INFO
- Always suggest the corrected code, not just the problem
- Be direct, not diplomatic — this is engineering, not feelings
- Reference specific line numbers

Format each issue as:
[SEVERITY] Line X: Issue description
Fix: corrected code snippet
"""

def review_code(code: str, language: str) -> str:
    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=2000,
        system=SYSTEM_PROMPT,
        messages=[{
            "role": "user",
            "content": f"Review this {language} code:\n\n```{language}\n{code}\n```"
        }]
    )
    return response.content[0].text

CLASSIFICATION_PROMPT = """Classify customer support tickets into categories.

Category definitions:
- BILLING: payment issues, refunds, invoice questions
- TECHNICAL: bugs, errors, feature not working
- ACCOUNT: login, password, permissions
- FEATURE_REQUEST: suggestions for new functionality
- OTHER: anything that doesn't fit above

Examples:

Ticket: "I was charged twice for my subscription last month"
<reasoning>This is about a payment issue — duplicate charge</reasoning>
Category: BILLING

Ticket: "The export button gives me a 500 error"
<reasoning>This is a technical error with a specific feature</reasoning>
Category: TECHNICAL

Ticket: "Would love to see dark mode added"
<reasoning>This is a suggestion for new functionality</reasoning>
Category: FEATURE_REQUEST

Now classify this ticket:
{ticket_text}

<reasoning>Think through which category fits best</reasoning>
Category:"""

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.core.retrievers import VectorIndexRetriever
from llama_index.core.query_engine import RetrieverQueryEngine
from llama_index.core.postprocessor import SentenceTransformerRerank
from llama_index.vector_stores.qdrant import QdrantVectorStore
import qdrant_client

# Setup
qdrant = qdrant_client.QdrantClient("localhost", port=6333)
vector_store = QdrantVectorStore(client=qdrant, collection_name="docs")

# Reranker for precision boost
reranker = SentenceTransformerRerank(
    model="cross-encoder/ms-marco-MiniLM-L-12-v2",
    top_n=3  # After reranking, keep top 3
)

# Build retriever with hybrid search
retriever = VectorIndexRetriever(
    index=index,
    similarity_top_k=10,  # Retrieve 10, rerank to 3
    vector_store_query_mode="hybrid",  # BM25 + vector
)

query_engine = RetrieverQueryEngine(
    retriever=retriever,
    node_postprocessors=[reranker],
)

response = query_engine.query("What is our refund policy?")

from langchain.agents import create_react_agent, AgentExecutor
from langchain.tools import Tool
from langchain_anthropic import ChatAnthropic

llm = ChatAnthropic(model="claude-sonnet-4-5")

tools = [
    Tool(
        name="search_knowledge_base",
        func=lambda q: query_engine.query(q).response,
        description="Search internal documentation for company policies, procedures, and technical specs",
    ),
    Tool(
        name="search_recent_incidents",
        func=lambda q: incident_db.search(q),
        description="Search recent support tickets and known issues from the last 30 days",
    ),
    Tool(
        name="lookup_customer",
        func=lambda customer_id: crm.get_customer(customer_id),
        description="Get customer account details, subscription status, and history",
    ),
]

agent = create_react_agent(llm, tools, prompt=REACT_PROMPT)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# The agent decides which tools to call and when
result = agent_executor.invoke({
    "input": "Customer 12345 is asking why they can't access the dashboard after upgrading"
})

from dataclasses import dataclass
from typing import Optional
import time

@dataclass
class RAGMetrics:
    query: str
    retrieved_docs: int
    latency_ms: float
    answer_relevance_score: float  # 0-1, measured by LLM judge
    groundedness_score: float       # Is the answer grounded in retrieved docs?
    context_utilization: float      # How much retrieved context was used?
    
def evaluate_rag_response(query, response, retrieved_docs, answer):
    """Use an LLM as judge to score RAG quality"""
    judge_prompt = f"""
    Query: {query}
    Retrieved context: {retrieved_docs}
    Answer: {answer}
    
    Score the following on a 0-10 scale:
    1. Answer Relevance: Does the answer address the query?
    2. Groundedness: Is the answer supported by the context?
    3. Context Utilization: Was the relevant context actually used?
    
    Return JSON: relevance
    """
    # ... call LLM judge

from openai import OpenAI
import json

client = OpenAI()

# Prepare training data (JSONL format)
training_examples = [
    {
        "messages": [
            {"role": "system", "content": "You are a JSON extractor for e-commerce orders."},
            {"role": "user", "content": "John ordered 3 blue widgets size L and 1 red gadget for delivery to NYC"},
            {"role": "assistant", "content": json.dumps({
                "items": [
                    {"name": "widget", "quantity": 3, "color": "blue", "size": "L"},
                    {"name": "gadget", "quantity": 1, "color": "red"}
                ],
                "delivery_city": "NYC",
                "customer_name": "John"
            })}
        ]
    },
    # ... hundreds more examples
]

# Save as JSONL
with open("training.jsonl", "w") as f:
    for example in training_examples:
        f.write(json.dumps(example) + "\n")

# Upload training file
training_file = client.files.create(
    file=open("training.jsonl", "rb"),
    purpose="fine-tune"
)

# Start fine-tuning job
job = client.fine_tuning.jobs.create(
    training_file=training_file.id,
    model="gpt-4o-mini",  # Much cheaper to fine-tune than gpt-4o
    hyperparameters={
        "n_epochs": 3,
        "batch_size": 16,
        "learning_rate_multiplier": 0.1,
    }
)

print(f"Fine-tuning job started: {job.id}")

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import get_peft_model, LoraConfig, TaskType
import torch

# Load base model
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.2-8B-Instruct",
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

# Configure LoRA
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=16,                    # Rank — higher = more parameters, better quality
    lora_alpha=32,
    lora_dropout=0.1,
    target_modules=[          # Which layers to adapt
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
    bias="none",
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# trainable params: 10,567,680 || all params: 8,041,000,960 || trainable%: 0.13%

def validate_training_example(example: dict) -> tuple[bool, str]:
    """Quality gates for training data"""
    messages = example.get("messages", [])
    
    # Must have all three roles
    roles = {m["role"] for m in messages}
    if not {"system", "user", "assistant"} <= roles:
        return False, "Missing required roles"
    
    # Assistant response must be substantial
    assistant_content = next(m["content"] for m in messages if m["role"] == "assistant")
    if len(assistant_content) < 50:
        return False, "Assistant response too short"
    
    # No hallucinated confidence
    bad_phrases = ["I'm not sure but", "I think maybe", "possibly could be"]
    if any(phrase in assistant_content.lower() for phrase in bad_phrases):
        return False, "Hedging language in training target"
    
    return True, "OK"

# Filter your dataset ruthlessly — 500 high-quality > 5000 mediocre
clean_examples = [ex for ex in raw_examples if validate_training_example(ex)[0]]
print(f"Kept {len(clean_examples)}/{len(raw_examples)} examples ({len(clean_examples)/len(raw_examples)*100:.1f}%)")