Framework Landscape

# LangGraph: Research Agent
from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
from langgraph.graph.message import add_messages
class ResearchState(TypedDict):
    messages: Annotated[list, add_messages]
    search_results: list
    report: str
def search_node(state):
    query = state["messages"][-1].content
    results = web_search(query)
    return {"search_results": results}
def write_node(state):
    report = llm.invoke(
        f"Write a research report based on:\n{state['search_results']}"
        )
    return {"report": report.content}
graph = StateGraph(ResearchState)
graph.add_node("search", search_node)
graph.add_node("write", write_node)
graph.set_entry_point("search")
graph.add_edge("search", "write")
graph.add_edge("write", END)
research_agent = graph.compile()

# CrewAI: Research Agent
from crewai import Agent, Task, Crew
researcher = Agent(
    role="Research Analyst",
    goal="Find comprehensive information on the given topic",
    tools=[web_search_tool],
    llm="gpt-4o",
)
writer = Agent(
    role="Report Writer",
    goal="Write a clear, well-structured research report",
    llm="gpt-4o",
)
search_task = Task(
    description="Research the topic: {topic}",
    agent=researcher,
    expected_output="A list of key findings with sources",
)
write_task = Task(
    description="Write a research report from the findings",
    agent=writer,
    expected_output="A well-structured research report",
    context=[search_task],
)
crew = Crew(agents=[researcher, writer], tasks=[search_task, write_task])
result = crew.kickoff(inputs={"topic": "quantum computing advances in 2025"})

# OpenAI Agents SDK: Research Agent
from openai import agents
search_agent = agents.Agent(
    name="researcher",
    instructions="Search the web for information on the given topic.",
    tools=[web_search_tool],
    model="gpt-4o",
)
writer_agent = agents.Agent(
    name="writer",
    instructions="Write a research report from the provided findings.",
    model="gpt-4o",
)
# Use handoff to chain agents
orchestrator = agents.Agent(
    name="orchestrator",
    instructions="Coordinate research: first search, then write a report.",
    handoffs=[search_agent, writer_agent],
    model="gpt-4o",
)
result = agents.Runner.run_sync(orchestrator, "Research quantum computing advances")

# Lab starter: framework selection skeleton. Students fill in the TODOs.
# Goal: given a list of candidate frameworks and a task description, score them.
from typing import Iterable
import numpy as np

FRAMEWORKS = ["LangGraph", "AutoGen", "CrewAI", "Swarm"]

def load_task_description() -> str:
    """TODO: load the task description from prompt.txt or your dataset."""
    raise NotImplementedError

def score_framework(name: str, description: str) -> float:
    """TODO: call your LLM with a scoring prompt; return a 0.0-1.0 fit score.
    Hints:
      - Build a small prompt template that lists the framework's strengths
      - Ask the model to rate task fit on a 0-10 scale, then divide by 10
    """
    raise NotImplementedError

def rank(frameworks: Iterable[str], description: str) -> list[tuple[str, float]]:
    """Score each candidate and return them sorted high-to-low."""
    scored = [(name, score_framework(name, description)) for name in frameworks]
    return sorted(scored, key=lambda x: -x[1])

if __name__ == "__main__":
    task = load_task_description()
    for name, fit in rank(FRAMEWORKS, task):
        print(f"  {name:>10s}: {fit:.2f}")

# Full solution for the framework-selection lab.
# Uses an LLM judge to score each candidate on the task description.
from openai import OpenAI
from pathlib import Path

client = OpenAI()

FRAMEWORKS = {
    "LangGraph": "Strong for explicit graph-based control flow; good with cycles and conditional edges; native LangChain integration.",
    "AutoGen":   "Optimized for conversational multi-agent systems; group chat patterns; human-in-the-loop friendly.",
    "CrewAI":    "Role-based agents (manager, researcher, writer); sequential or hierarchical processes; simple API.",
    "Swarm":     "Minimal, stateless agent routing primitives; good for tool-handoff patterns; easy to inspect.",
}

JUDGE_PROMPT = """Rate how well the framework below fits the task on a 0-10 scale.
Return ONLY a number between 0 and 10.

Framework: {name}
Description: {desc}

Task: {task}

Score:"""

def load_task_description() -> str:
    p = Path("prompt.txt")
    if p.exists(): return p.read_text(encoding="utf-8")
    return "Build a 3-agent pipeline for researching, drafting, and editing news articles."

def score_framework(name: str, task: str) -> float:
    resp = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": JUDGE_PROMPT.format(name=name, desc=FRAMEWORKS[name], task=task)}],
        temperature=0.0,
        max_tokens=4,
    )
    try:
        return float(resp.choices[0].message.content.strip()) / 10.0
    except ValueError:
        return 0.5

if __name__ == "__main__":
    task = load_task_description()
    scored = sorted(((n, score_framework(n, task)) for n in FRAMEWORKS), key=lambda x: -x[1])
    print(f"Task: {task!r}\n")
    for name, fit in scored:
        print(f"  {name:>10s}: {fit:.2f}")