LLM vs RAG vs AI Agent
vs Agentic AI

import anthropic

# 1. Initialise client — reads ANTHROPIC_API_KEY from environment
client = anthropic.Anthropic()

# 2. System prompt: who the assistant is and how it should behave
SYSTEM = """You are a friendly support assistant for Clarion,
a project management SaaS. Answer questions clearly and concisely.
If you do not know a specific answer, say so honestly rather than
guessing. Never fabricate feature names or pricing details."""

# 3. In-memory conversation history (list of message dicts)
history = []

def chat(user_message: str) -> str:
    history.append({"role": "user", "content": user_message})

    # 4. Call the Messages API with full history on every turn
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        system=SYSTEM,
        messages=history
    )

    assistant_text = response.content[0].text

    # Append assistant turn so next call includes it
    history.append({"role": "assistant", "content": assistant_text})
    return assistant_text

# 5. Simple interactive loop
if __name__ == "__main__":
    print("Clarion Support (LLM only). Type 'quit' to exit.\n")
    while True:
        q = input("You: ")
        if q.lower() == "quit": break
        print(f"\nClarion: {chat(q)}\n")

import anthropic, math

client = anthropic.Anthropic()

# ── STEP 1: Knowledge base (normally loaded from files or a DB) ──
DOCS = [
    "Clarion integrates with Jira, Asana, Linear, and GitHub via OAuth.",
    "Clarion pricing: Starter $12/user/month, Pro $28/user/month, Enterprise custom.",
    "To reset your password: go to Settings > Security > Reset Password.",
    "Clarion supports SSO via SAML 2.0 on Pro and Enterprise plans.",
    "File upload limit is 50 MB per file on Starter; 500 MB on Pro.",
    "API rate limit is 1,000 requests/hour on Pro; 10,000/hour on Enterprise.",
]

# ── STEP 2: Toy embedding (word-overlap; replace with a real model) ──
def embed(text):
    words = text.lower().split()
    vec = {}
    for w in words: vec[w] = vec.get(w, 0) + 1
    return vec

def cosine(a, b):
    keys = set(a) & set(b)
    dot  = sum(a[k] * b[k] for k in keys)
    mag  = (math.sqrt(sum(v**2 for v in a.values())) *
            math.sqrt(sum(v**2 for v in b.values())))
    return dot / mag if mag else 0

doc_vecs = [(embed(d), d) for d in DOCS]

# ── STEP 3 + 4: Retrieve top-K chunks ──
def retrieve(query, k=3):
    qvec   = embed(query)
    scored = [(cosine(qvec, dv), doc) for dv, doc in doc_vecs]
    scored.sort(reverse=True)
    return [doc for _, doc in scored[:k]]

# ── STEP 5 + 6: Augment and call Claude ──
def rag_chat(question):
    chunks  = retrieve(question)
    context = "\n".join(f"- {c}" for c in chunks)

    prompt = f"""Answer using ONLY the context below.
If the answer is not there, say: "I don't have that in my knowledge base."

Context:
{context}

Question: {question}"""

    r = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=512,
        messages=[{"role": "user", "content": prompt}]
    )
    return r.content[0].text

if __name__ == "__main__":
    for q in [
        "Does Clarion integrate with Jira?",
        "What is the file upload limit on the Starter plan?",
        "Can I use my own email domain?",    # not in KB
    ]:
        print(f"Q: {q}\nA: {rag_chat(q)}\n")

import anthropic, json

client = anthropic.Anthropic()

# ── STEP 1: Tool definitions ──────────────────────────────────────
TOOLS = [
    {
        "name": "get_account_status",
        "description": "Look up a Clarion account by email. Returns plan, status, and last login.",
        "input_schema": {
            "type": "object",
            "properties": {"email": {"type": "string"}},
            "required": ["email"]
        }
    },
    {
        "name": "create_ticket",
        "description": "Create a support ticket when the issue cannot be resolved in chat.",
        "input_schema": {
            "type": "object",
            "properties": {
                "email":    {"type": "string"},
                "subject":  {"type": "string"},
                "priority": {"type": "string", "enum": ["low", "medium", "high"]}
            },
            "required": ["email", "subject", "priority"]
        }
    }
]

# ── STEP 2: Tool implementations (mocked — replace with real calls) ─
def get_account_status(email):
    db = {
        "alice@example.com": {"plan": "Pro",     "status": "active",    "last_login": "2026-05-02"},
        "bob@example.com":   {"plan": "Starter", "status": "suspended", "last_login": "2026-03-10"},
    }
    return db.get(email, {"error": "Account not found"})

def create_ticket(email, subject, priority):
    ticket_id = f"TKT-{abs(hash(email+subject)) % 10000:04d}"
    print(f"  [TICKET CREATED] {ticket_id}: {subject} ({priority}) for {email}")
    return {"ticket_id": ticket_id, "status": "created"}

def execute_tool(name, inputs):
    if   name == "get_account_status": return get_account_status(**inputs)
    elif name == "create_ticket":      return create_ticket(**inputs)
    raise ValueError(f"Unknown tool: {name}")

# ── STEP 3: The agent loop ────────────────────────────────────────
def run_agent(user_message):
    messages = [{"role": "user", "content": user_message}]

    for step in range(10):                        # STEP 4: max 10 iterations
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=1024,
            tools=TOOLS,
            messages=messages,
            system="You are a Clarion support agent. Use get_account_status "
                   "before answering any account-specific questions."
        )

        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                result = execute_tool(block.name, block.input)
                tool_results.append({
                    "type":        "tool_result",
                    "tool_use_id": block.id,
                    "content":     json.dumps(result)
                })

        messages.append({"role": "assistant", "content": response.content})

        if not tool_results:
            return next(b.text for b in response.content if b.type == "text")

        messages.append({"role": "user", "content": tool_results})

    return "Max steps reached without a final answer."

if __name__ == "__main__":
    q = "My account is alice@example.com and I can't upload files larger than 10 MB."
    print(f"User: {q}\n")
    print(f"Agent: {run_agent(q)}")

import anthropic, json

client = anthropic.Anthropic()

# ══ SUB-AGENT 1: Billing Agent ════════════════════════════════════
BILLING_TOOLS = [{
    "name": "check_invoice",
    "description": "Check invoice and payment status for a Clarion account.",
    "input_schema": {
        "type": "object",
        "properties": {"email": {"type": "string"}},
        "required": ["email"]
    }
}]

def check_invoice(email):
    return {"invoice": "INV-0042", "amount": "$28",
            "status": "paid", "due": "2026-05-01"}

def billing_agent(task):
    print(f"  [BILLING AGENT] {task}")
    messages = [{"role": "user", "content": task}]
    for _ in range(5):
        r = client.messages.create(
            model="claude-sonnet-4-20250514", max_tokens=512,
            system="You are the Clarion billing specialist. Only handle billing and payment questions.",
            tools=BILLING_TOOLS, messages=messages
        )
        tool_results = []
        for b in r.content:
            if b.type == "tool_use":
                res = check_invoice(**b.input)
                tool_results.append({"type": "tool_result",
                                     "tool_use_id": b.id, "content": json.dumps(res)})
        messages.append({"role": "assistant", "content": r.content})
        if not tool_results:
            return next(b.text for b in r.content if b.type == "text")
        messages.append({"role": "user", "content": tool_results})
    return "Billing agent could not resolve."

# ══ SUB-AGENT 2: Technical Agent ══════════════════════════════════
def technical_agent(task):
    print(f"  [TECH AGENT] {task}")
    r = client.messages.create(
        model="claude-sonnet-4-20250514", max_tokens=512,
        system="You are Clarion's technical support specialist. Diagnose technical issues. "
               "If you cannot resolve, recommend opening a bug report.",
        messages=[{"role": "user", "content": task}]
    )
    return r.content[0].text

# ══ ORCHESTRATOR ══════════════════════════════════════════════════
ORCH_TOOLS = [
    {
        "name": "route_to_billing",
        "description": "Route to the billing specialist for invoices, payments, or plan changes.",
        "input_schema": {"type": "object",
                         "properties": {"task": {"type": "string"}},
                         "required": ["task"]}
    },
    {
        "name": "route_to_technical",
        "description": "Route to the technical specialist for bugs, errors, integrations, or performance.",
        "input_schema": {"type": "object",
                         "properties": {"task": {"type": "string"}},
                         "required": ["task"]}
    }
]

def orchestrate(user_message):
    messages = [{"role": "user", "content": user_message}]

    for _ in range(6):
        r = client.messages.create(
            model="claude-sonnet-4-20250514", max_tokens=1024,
            system="You are the Clarion support orchestrator. Analyse the user's issue "
                   "and route to the appropriate specialist. You may call multiple agents "
                   "if the issue spans billing and technical concerns.",
            tools=ORCH_TOOLS, messages=messages
        )
        tool_results = []
        for b in r.content:
            if b.type == "tool_use":
                result = (billing_agent(b.input["task"]) if b.name == "route_to_billing"
                          else technical_agent(b.input["task"]))
                tool_results.append({"type": "tool_result",
                                     "tool_use_id": b.id, "content": result})
        messages.append({"role": "assistant", "content": r.content})
        if not tool_results:
            return next(b.text for b in r.content if b.type == "text")
        messages.append({"role": "user", "content": tool_results})
    return "Orchestrator could not resolve."

if __name__ == "__main__":
    msg = ("Hi, I'm alice@example.com. My last invoice looks wrong AND "
           "the Jira integration stopped syncing yesterday.")
    print(f"User: {msg}\n")
    print(f"System: {orchestrate(msg)}")