from dotenv import load_dotenv
from langchain_groq import ChatGroq
from langchain_core.messages import HumanMessage

# Load variables from the project's .env file
load_dotenv()

llm = ChatGroq(model="llama-3.3-70b-versatile")

# Pipeline: one-shot
response = llm.invoke([HumanMessage("Summarise quantum computing in 2 sentences")])
print(response.content)

from dotenv import load_dotenv
from langchain_groq import ChatGroq
from langchain_core.messages import HumanMessage, SystemMessage

# Load variables from the project's .env file
load_dotenv()

llm = ChatGroq(model="llama-3.3-70b-versatile")

def simple_agent(question: str, max_steps: int = 5):
    system = SystemMessage("""You are a reasoning agent. For each step:
1. Think about what you know
2. Give your best answer
3. If fully answered, end your response with DONE
Otherwise continue reasoning.""")
    messages = [system, HumanMessage(question)]
    for step in range(max_steps):
        response = llm.invoke(messages)
        print(f"Step {step+1}: {response.content[:200]}...")
        messages.append(response)
        if "DONE" in response.content:
            print("Agent finished.")
            break
    return messages[-1].content

result = simple_agent("What are the top 3 benefits of using LangGraph? What's the scene of AI in the republic of Korea?")
print(result)

from langchain_groq import ChatGroq
from langchain_core.messages import HumanMessage
from langchain_core.tools import tool
from langgraph.graph import StateGraph, MessagesState, START
from langgraph.prebuilt import ToolNode, tools_condition
from dotenv import load_dotenv

# Load variables from the project's .env file
load_dotenv()

# 1. Define a tool
@tool
def add(a: int, b: int) -> int:
    """Add two integers."""
    return a + b


# 2. Create the LLM and give it access to the tool
llm = ChatGroq(
    model="llama-3.3-70b-versatile",
    temperature=0
)

llm_with_tools = llm.bind_tools([add])


# 3. Define the reasoning node
def reasoning_node(state: MessagesState):
    response = llm_with_tools.invoke(state["messages"])
    return {"messages": [response]}


# 4. Build the workflow
workflow = StateGraph(MessagesState)

workflow.add_node("reason", reasoning_node)
workflow.add_node("tools", ToolNode([add]))

workflow.add_edge(START, "reason")
workflow.add_conditional_edges("reason", tools_condition)
workflow.add_edge("tools", "reason")


# 5. Compile and run
app = workflow.compile()

result = app.invoke({
    "messages": [
        HumanMessage(content="What is 2 + 2? Use the add tool.")
    ]
})

print(result["messages"][-1].content)

from langchain_groq import ChatGroq
from langchain_core.messages import HumanMessage
from langchain_core.tools import tool
from langgraph.graph import StateGraph, MessagesState, START, END
from langgraph.prebuilt import ToolNode
from dotenv import load_dotenv


# Load variables from the project's .env file
load_dotenv()


# 1. Define the tool
@tool
def add(a: int, b: int) -> int:
    """Add two integers."""
    return a + b


# 2. Create the model and bind the tool
llm = ChatGroq(
    model="llama-3.3-70b-versatile",
    temperature=0
)

llm_with_tools = llm.bind_tools([add])


# 3. Reasoning node
def reasoning_node(state: MessagesState):
    response = llm_with_tools.invoke(state["messages"])
    return {"messages": [response]}


# 4. Decide whether to call a tool or finish
def should_continue(state: MessagesState) -> str:
    last_message = state["messages"][-1]

    if getattr(last_message, "tool_calls", None):
        return "continue"

    return "end"


# 5. Build the workflow
workflow = StateGraph(MessagesState)

workflow.add_node("reason", reasoning_node)
workflow.add_node("tools", ToolNode([add]))

workflow.add_edge(START, "reason")

workflow.add_conditional_edges(
    "reason",
    should_continue,
    {
        "continue": "tools",
        "end": END
    }
)

workflow.add_edge("tools", "reason")


# 6. Compile and run
app = workflow.compile()

result = app.invoke({
    "messages": [
        HumanMessage(content="What is 2 + 2? Use the add tool.")
    ]
})

print(result["messages"][-1].content)

"""Reusable tools for the Module 3 general-purpose agent."""

from __future__ import annotations
import ast, operator
from langchain_core.tools import tool
from dotenv import load_dotenv

load_dotenv()


@tool
def search_web(query: str) -> str:
    """Search the web for current information and return up to three results."""
    try:
        from ddgs import DDGS
        results = DDGS().text(query, max_results=3)
        if not results:
            return "No web results found."
        return "\n\n".join(
            f"{item.get('title', 'Untitled')}\n"
            f"{item.get('body', 'No summary available')}\n"
            f"{item.get('href', '')}"
            for item in results
        )
    except Exception as exc:
        return f"Web search failed: {exc}"


@tool
def lookup_wikipedia(topic: str) -> str:
    """Look up a topic on Wikipedia and return a four-sentence summary."""
    try:
        import wikipedia
        return wikipedia.summary(topic, sentences=4, auto_suggest=False)
    except wikipedia.DisambiguationError as exc:
        suggestions = ", ".join(exc.options[:3])
        return f"The topic is ambiguous. Try one of: {suggestions}"
    except wikipedia.PageError:
        return f"No Wikipedia page was found for '{topic}'."
    except Exception as exc:
        return f"Wikipedia lookup failed: {exc}"


_BINARY_OPERATORS = {
    ast.Add: operator.add, ast.Sub: operator.sub,
    ast.Mult: operator.mul, ast.Div: operator.truediv,
    ast.FloorDiv: operator.floordiv, ast.Mod: operator.mod, ast.Pow: operator.pow,
}
_UNARY_OPERATORS = {ast.UAdd: operator.pos, ast.USub: operator.neg}


def _evaluate(node):
    if isinstance(node, ast.Expression): return _evaluate(node.body)
    if isinstance(node, ast.Constant) and type(node.value) in (int, float): return node.value
    if isinstance(node, ast.BinOp) and type(node.op) in _BINARY_OPERATORS:
        return _BINARY_OPERATORS[type(node.op)](_evaluate(node.left), _evaluate(node.right))
    if isinstance(node, ast.UnaryOp) and type(node.op) in _UNARY_OPERATORS:
        return _UNARY_OPERATORS[type(node.op)](_evaluate(node.operand))
    raise ValueError("Only numbers and basic arithmetic operators are allowed.")


@tool
def calculate(expression: str) -> str:
    """Safely evaluate a basic arithmetic expression."""
    try:
        return str(_evaluate(ast.parse(expression, mode="eval")))
    except Exception as exc:
        return f"Calculation failed: {exc}"


@tool
def get_stock_price(ticker: str) -> str:
    """Return the latest available stock price from Yahoo Finance."""
    try:
        import yfinance as yf
        clean_ticker = ticker.strip().upper()
        stock = yf.Ticker(clean_ticker)
        try:
            price = stock.fast_info["lastPrice"]
        except Exception:
            history = stock.history(period="5d")
            if history.empty:
                return f"No recent price was found for {clean_ticker}."
            price = history["Close"].dropna().iloc[-1]
        return f"{clean_ticker}: ${float(price):,.2f}"
    except Exception as exc:
        return f"Stock lookup failed: {exc}"


tools = [search_web, lookup_wikipedia, calculate, get_stock_price]

"""A LangGraph agent that selects and executes general-purpose tools."""

from __future__ import annotations
from typing import Literal
from langchain_core.messages import HumanMessage
from langchain_groq import ChatGroq
from langgraph.graph import END, START, MessagesState, StateGraph
from langgraph.prebuilt import ToolNode
from custom_tools import tools   # make sure custom_tools.py is in the same folder
from dotenv import load_dotenv

load_dotenv()

model_with_tools = ChatGroq(
    model="llama-3.3-70b-versatile",
    temperature=0,
    max_retries=2
).bind_tools(tools)


def agent_node(state: MessagesState) -> dict:
    """Ask the model to answer directly or request one or more tools."""
    response = model_with_tools.invoke(state["messages"])
    return {"messages": [response]}


def should_use_tools(state: MessagesState) -> Literal["tools", "end"]:
    """Route requested tool calls to ToolNode; otherwise finish."""
    last_message = state["messages"][-1]
    return "tools" if getattr(last_message, "tool_calls", None) else "end"


workflow = StateGraph(MessagesState)
workflow.add_node("agent", agent_node)
workflow.add_node("tools", ToolNode(tools))

workflow.add_edge(START, "agent")
workflow.add_conditional_edges(
    "agent",
    should_use_tools,
    {"tools": "tools", "end": END},
)
workflow.add_edge("tools", "agent")

app = workflow.compile()


if __name__ == "__main__":
    result = app.invoke(
        {
            "messages": [
                HumanMessage(
                    content=(
                        "Use the appropriate tools to find the latest available "
                        "price of AAPL stock and calculate 1500 * 1.08."
                    )
                )
            ]
        }
    )
    print(result["messages"][-1].content)

"""A guarded supervisor/worker workflow with three specialized agents."""

from __future__ import annotations
import operator
from typing import Annotated, Literal, TypedDict
from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
from langchain_groq import ChatGroq
from langgraph.graph import END, START, StateGraph
from dotenv import load_dotenv

load_dotenv()

AgentName = Literal["researcher", "analyst", "writer", "FINISH"]

class CollaborativeState(TypedDict):
    messages: Annotated[list[BaseMessage], operator.add]
    task: str
    research_result: str
    analysis_result: str
    final_report: str
    next_agent: AgentName
    route_history: Annotated[list[str], operator.add]

llm = ChatGroq(model="llama-3.3-70b-versatile", temperature=0)

def required_next_agent(state):
    if not state["research_result"]: return "researcher"
    if not state["analysis_result"]: return "analyst"
    if not state["final_report"]:    return "writer"
    return "FINISH"

def supervisor_node(state):
    required = required_next_agent(state)
    if required == "FINISH":
        return {"next_agent": "FINISH", "route_history": ["FINISH"]}
    # ... (see full file for LLM routing logic)
    return {"next_agent": required, "route_history": [required]}

def researcher_node(state):
    response = llm.invoke([
        SystemMessage("You are the Researcher. Gather relevant background from your knowledge."),
        HumanMessage(f"Research this topic:\n{state['task']}"),
    ])
    return {"research_result": response.content, "messages": [response]}

def analyst_node(state):
    response = llm.invoke([
        SystemMessage("You are the Analyst. Extract key insights from the research."),
        HumanMessage(f"Task:\n{state['task']}\n\nResearch:\n{state['research_result']}"),
    ])
    return {"analysis_result": response.content, "messages": [response]}

def writer_node(state):
    response = llm.invoke([
        SystemMessage("You are the Writer. Produce a clear, concise report."),
        HumanMessage(f"Task:\n{state['task']}\n\nResearch:\n{state['research_result']}\n\nAnalysis:\n{state['analysis_result']}"),
    ])
    return {"final_report": response.content, "messages": [response]}

workflow = StateGraph(CollaborativeState)
workflow.add_node("supervisor", supervisor_node)
workflow.add_node("researcher", researcher_node)
workflow.add_node("analyst", analyst_node)
workflow.add_node("writer", writer_node)

workflow.add_edge(START, "supervisor")
workflow.add_conditional_edges("supervisor", lambda s: s["next_agent"],
    {"researcher": "researcher", "analyst": "analyst", "writer": "writer", "FINISH": END})
workflow.add_edge("researcher", "supervisor")
workflow.add_edge("analyst", "supervisor")
workflow.add_edge("writer", "supervisor")
app = workflow.compile()

if __name__ == "__main__":
    topic = "Benefits and risks of using AI agents in university education"
    result = app.invoke({
        "messages": [HumanMessage(content=topic)],
        "task": topic,
        "research_result": "", "analysis_result": "", "final_report": "",
        "next_agent": "researcher", "route_history": [],
    }, config={"recursion_limit": 10})
    print("\nRoute history:", " -> ".join(result["route_history"]))
    print("\nFINAL REPORT\n")
    print(result["final_report"])

"""Module 5: Decision Intelligence Agents.

Install:
    pip install -U langgraph langchain-groq pydantic

Set your API key before running:
    Linux/macOS: export GROQ_API_KEY="your-key"
    Windows PowerShell: $env:GROQ_API_KEY="your-key"
    Or add to PyCharm: Run > Edit Configurations > Environment variables
"""

from __future__ import annotations
import json, os
from functools import lru_cache
from typing import Any
from langchain_core.messages import HumanMessage, SystemMessage
from langchain_groq import ChatGroq
from langgraph.graph import END, START, StateGraph
from pydantic import BaseModel, Field
from typing_extensions import NotRequired, TypedDict
from dotenv import load_dotenv

load_dotenv()


class QualitativeOptionScore(BaseModel):
    option: str = Field(description="The option name, copied exactly from the input")
    strategic_fit: int = Field(ge=1, le=10)
    stakeholder_acceptance: int = Field(ge=1, le=10)
    implementation_complexity: int = Field(ge=1, le=10)
    long_term_sustainability: int = Field(ge=1, le=10)
    rationale: str

class QualitativeEvaluation(BaseModel):
    scores: list[QualitativeOptionScore]


class DecisionState(TypedDict):
    decision_question: str
    options: list[str]
    decision_context: NotRequired[str]
    qualitative_scores: NotRequired[dict[str, Any]]
    quantitative_scores: NotRequired[dict[str, Any]]
    risk_assessment: NotRequired[dict[str, Any]]
    final_recommendation: NotRequired[dict[str, Any]]
    confidence: NotRequired[float]


@lru_cache(maxsize=1)
def get_llm() -> ChatGroq:
    if not os.getenv("GROQ_API_KEY"):
        raise RuntimeError("GROQ_API_KEY is not set.")
    return ChatGroq(model=os.getenv("GROQ_MODEL", "llama-3.3-70b-versatile"), temperature=0, max_retries=2)


def validate_input(state):
    question = state.get("decision_question", "").strip()
    options = [o.strip() for o in state.get("options", []) if o.strip()]
    if not question: raise ValueError("decision_question cannot be empty.")
    if len(options) < 2: raise ValueError("Provide at least two decision options.")
    return {"decision_question": question, "options": options}

def qualitative_evaluator(state):
    # Scores each option on strategic fit, stakeholder acceptance, etc.
    ...  # see full file for implementation

def quantitative_evaluator(state):
    # Estimates ROI, cost, and time to value for each option
    ...

def risk_assessor(state):
    # Identifies top 3 risks per option with probability and impact
    ...

def recommendation_synthesizer(state):
    # Combines all evaluations into a structured final recommendation
    ...


workflow = StateGraph(DecisionState)
workflow.add_node("validate", validate_input)
workflow.add_node("qualitative", qualitative_evaluator)
workflow.add_node("quantitative", quantitative_evaluator)
workflow.add_node("risks", risk_assessor)
workflow.add_node("recommend", recommendation_synthesizer)

workflow.add_edge(START, "validate")

# Fan out: three evaluators run in parallel
workflow.add_edge("validate", "qualitative")
workflow.add_edge("validate", "quantitative")
workflow.add_edge("validate", "risks")

# Fan in: synthesizer waits for all three
workflow.add_edge(["qualitative", "quantitative", "risks"], "recommend")
workflow.add_edge("recommend", END)

decision_app = workflow.compile()


if __name__ == "__main__":
    output = decision_app.invoke({
        "decision_question": "Which approach should our university use for a student-support chatbot?",
        "options": ["Build an in-house solution", "Buy a commercial platform", "Run a limited hybrid pilot"],
        "decision_context": "The university needs a pilot within six months, has a modest budget, handles sensitive student data.",
    })
    print("\nFINAL RECOMMENDATION")
    print(json.dumps(output["final_recommendation"], indent=2))

"""Module 6: Scaling Agentic Systems.

Install:
    pip install -U langgraph langchain-groq langgraph-checkpoint-sqlite

Run the demonstration:
    python module_6_scaling_agentic_systems.py

Run the evaluation suite (uses live model calls):
    python module_6_scaling_agentic_systems.py --eval

Require human approval before returning the answer:
    python module_6_scaling_agentic_systems.py --human-review
"""

from __future__ import annotations
import os, time, uuid, argparse
from functools import lru_cache
from langchain_core.rate_limiters import InMemoryRateLimiter
from langchain_groq import ChatGroq
from langgraph.checkpoint.sqlite import SqliteSaver
from langgraph.graph import END, START, StateGraph
from langgraph.types import RetryPolicy, interrupt
from dotenv import load_dotenv

load_dotenv()

DEFAULT_MAX_AGENT_STEPS = 6
DEFAULT_TOKEN_BUDGET    = 6_000

# ── 1. Rate-limited, tool-bound model ──────────────────────────────────
@lru_cache(maxsize=1)
def get_agent_model():
    if not os.getenv("GROQ_API_KEY"):
        raise RuntimeError("GROQ_API_KEY is not set.")
    limiter = InMemoryRateLimiter(requests_per_second=0.5, check_every_n_seconds=0.1, max_bucket_size=1)
    model = ChatGroq(model="llama-3.3-70b-versatile", temperature=0, max_tokens=600, max_retries=0, timeout=30, rate_limiter=limiter)
    return model.bind_tools(TOOLS)


# ── 2. Bounded agent node with token guard ──────────────────────────────
def safe_agent_node(state):
    max_steps  = min(state.get("max_steps", DEFAULT_MAX_AGENT_STEPS), 10)
    step_count = state.get("step_count", 0)
    if step_count >= max_steps:
        return {"status": "stopped", "final_answer": "", "errors": ["Maximum steps reached."]}
    # ... invoke model, track tokens, update state
    ...


# ── 3. Recoverable tool execution ───────────────────────────────────────
def execute_tools_node(state):
    # Expected tool failures become ToolMessages; unexpected ones are caught
    # so a single tool error does not crash the whole workflow.
    ...


# ── 4. Optional human-review interrupt ──────────────────────────────────
def human_review_node(state):
    decision = interrupt({"question": "Approve this agent answer?", "answer": state.get("final_answer", "")})
    approved = decision if isinstance(decision, bool) else decision.get("approved", False)
    return {"status": "approved" if approved else "rejected"}


# ── 5. Graph with retries and checkpointing ─────────────────────────────
def build_agent(checkpointer=None):
    workflow = StateGraph(AgentState)
    workflow.add_node("agent", safe_agent_node,
        retry_policy=RetryPolicy(max_attempts=3, initial_interval=1.0, backoff_factor=2.0, jitter=True))
    workflow.add_node("tools", execute_tools_node)
    workflow.add_node("human_review", human_review_node)
    workflow.add_edge(START, "agent")
    workflow.add_conditional_edges("agent", route_after_agent,
        {"tools": "tools", "review": "human_review", "end": END})
    workflow.add_edge("tools", "agent")
    workflow.add_edge("human_review", END)
    return workflow.compile(checkpointer=checkpointer)


# ── 6. Entry point — SQLite checkpoint DB ──────────────────────────────
if __name__ == "__main__":
    with SqliteSaver.from_conn_string("module_6_checkpoints.sqlite") as checkpointer:
        app = build_agent(checkpointer)
        thread_id = f"demo-{uuid.uuid4()}"
        config = {"configurable": {"thread_id": thread_id}, "recursion_limit": 25}
        result = app.invoke(initial_state("What is the late-registration fee for 3 students?"), config=config)
        print(result.get("final_answer", "No answer released."))

python module_6_scaling_agentic_systems.py --eval