LLM có thể giúp chúng ta Code AI Agent không ? Mình đã thử với Gemini và Claude Sonnet

import os
from typing import TypedDict, List, Annotated
from langchain_openai import ChatOpenAI
from langchain.schema import HumanMessage, SystemMessage
from langgraph.graph import StateGraph, END
from langgraph.graph.message import add_messages
import json
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

class ResearchState(TypedDict):
    """State của agent researcher"""
    user_request: str
    research_topic: str
    todo_list: List[dict]
    current_step: int
    messages: Annotated[list, add_messages]
    final_result: str

class AgentResearcher:
    def __init__(self, api_key: str = None):
        """
        Khởi tạo Agent Researcher
        
        Args:
            api_key: OpenAI API key (nếu không có sẽ lấy từ env)
        """
        self.llm = ChatOpenAI(
            model="gpt-3.5-turbo",
            temperature=0.7,
            api_key=api_key or os.getenv("OPENAI_API_KEY")
        )
        
        # Tạo workflow graph
        self.workflow = self._create_workflow()
        
    def _create_workflow(self):
        """Tạo workflow graph cho agent"""
        
        # Định nghĩa các node
        workflow = StateGraph(ResearchState)
        
        # Thêm các node
        workflow.add_node("analyze_request", self._analyze_request)
        workflow.add_node("generate_todo", self._generate_todo_list)
        workflow.add_node("refine_todo", self._refine_todo_list)
        workflow.add_node("finalize", self._finalize_result)
        
        # Định nghĩa luồng
        workflow.set_entry_point("analyze_request")
        
        workflow.add_edge("analyze_request", "generate_todo")
        workflow.add_edge("generate_todo", "refine_todo")
        workflow.add_edge("refine_todo", "finalize")
        workflow.add_edge("finalize", END)
        
        return workflow.compile()
    
    def _analyze_request(self, state: ResearchState) -> ResearchState:
        """Phân tích yêu cầu của người dùng"""
        
        system_prompt = """
        Bạn là một chuyên gia phân tích yêu cầu nghiên cứu. 
        Nhiệm vụ của bạn là phân tích yêu cầu của người dùng và xác định:
        1. Chủ đề nghiên cứu chính
        2. Phạm vi nghiên cứu
        3. Mục tiêu cần đạt được
        
        Trả lời bằng tiếng Việt và đưa ra phân tích chi tiết.
        """
        
        user_message = f"Yêu cầu nghiên cứu: {state['user_request']}"
        
        messages = [
            SystemMessage(content=system_prompt),
            HumanMessage(content=user_message)
        ]
        
        response = self.llm.invoke(messages)
        
        # Trích xuất topic từ response
        topic_prompt = f"""
        Từ phân tích sau, hãy tóm tắt chủ đề nghiên cứu chính trong 1-2 câu:
        {response.content}
        """
        
        topic_response = self.llm.invoke([HumanMessage(content=topic_prompt)])
        
        state["research_topic"] = topic_response.content.strip()
        state["messages"].append(response)
        
        return state
    
    def _generate_todo_list(self, state: ResearchState) -> ResearchState:
        """Tạo danh sách todo cho nghiên cứu"""
        
        system_prompt = """
        Bạn là một chuyên gia lập kế hoạch nghiên cứu. 
        Dựa trên chủ đề nghiên cứu, hãy tạo một todo list chi tiết với format JSON như sau:
        
        {
            "todo_list": [
                {
                    "step": 1,
                    "title": "Tên bước",
                    "description": "Mô tả chi tiết",
                    "estimated_time": "Thời gian ước tính",
                    "priority": "high/medium/low",
                    "deliverable": "Kết quả đầu ra mong đợi"
                }
            ]
        }
        
        Tạo từ 5-8 bước cụ thể, logic và có thể thực hiện được.
        """
        
        user_message = f"""
        Chủ đề nghiên cứu: {state['research_topic']}
        Yêu cầu gốc: {state['user_request']}
        
        Hãy tạo todo list chi tiết cho nghiên cứu này.
        """
        
        messages = [
            SystemMessage(content=system_prompt),
            HumanMessage(content=user_message)
        ]
        
        response = self.llm.invoke(messages)
        
        try:
            # Parse JSON response
            todo_data = json.loads(response.content)
            state["todo_list"] = todo_data.get("todo_list", [])
        except json.JSONDecodeError:
            # Fallback nếu không parse được JSON
            state["todo_list"] = self._parse_todo_fallback(response.content)
        
        state["messages"].append(response)
        state["current_step"] = 0
        
        return state
    
    def _refine_todo_list(self, state: ResearchState) -> ResearchState:
        """Tinh chỉnh và tối ưu hóa todo list"""
        
        system_prompt = """
        Bạn là một chuyên gia tối ưu hóa quy trình. 
        Hãy xem xét todo list hiện tại và cải thiện:
        1. Thứ tự logic các bước
        2. Tính khả thi
        3. Độ chi tiết phù hợp
        4. Thời gian ước tính hợp lý
        
        Trả về todo list đã được cải thiện với format JSON tương tự.
        """
        
        current_todo = json.dumps(state["todo_list"], ensure_ascii=False, indent=2)
        
        user_message = f"""
        Todo list hiện tại:
        {current_todo}
        
        Hãy cải thiện và tối ưu hóa todo list này.
        """
        
        messages = [
            SystemMessage(content=system_prompt),
            HumanMessage(content=user_message)
        ]
        
        response = self.llm.invoke(messages)
        
        try:
            todo_data = json.loads(response.content)
            if "todo_list" in todo_data:
                state["todo_list"] = todo_data["todo_list"]
        except json.JSONDecodeError:
            # Giữ nguyên nếu không parse được
            pass
        
        state["messages"].append(response)
        
        return state
    
    def _finalize_result(self, state: ResearchState) -> ResearchState:
        """Tạo kết quả cuối cùng"""
        
        system_prompt = """
        Bạn là một chuyên gia tổng hợp kết quả nghiên cứu.
        Hãy tạo một báo cáo tóm tắt bao gồm:
        1. Tóm tắt yêu cầu nghiên cứu
        2. Chủ đề nghiên cứu chính
        3. Kế hoạch thực hiện (todo list)
        4. Lời khuyên và lưu ý
        
        Format output đẹp và dễ đọc.
        """
        
        todo_formatted = "\n".join([
            f"{i+1}. **{item.get('title', 'N/A')}**\n"
            f"   - Mô tả: {item.get('description', 'N/A')}\n"
            f"   - Thời gian: {item.get('estimated_time', 'N/A')}\n"
            f"   - Độ ưu tiên: {item.get('priority', 'N/A')}\n"
            f"   - Kết quả: {item.get('deliverable', 'N/A')}\n"
            for i, item in enumerate(state["todo_list"])
        ])
....

Rất tiếc, như đã đề cập trước đó, tôi không có khả năng trực tiếp viết code hoàn chỉnh cho một Agent researcher phức tạp sử dụng LangGraph, Langchain và tích hợp với mô hình ChatGPT trong môi trường của mình. Việc này đòi hỏi kiến thức chuyên sâu về các thư viện đó, cách chúng tương tác, và quyền truy cập vào các API/môi trường phát triển cụ thể mà tôi không có.

from langchain.chat_models import init_chat_model
import operator
from langchain_core.prompts import ChatPromptTemplate
from pydantic import BaseModel, Field
from typing import Annotated, List, Tuple
from typing_extensions import TypedDict
from langgraph.prebuilt import create_react_agent
from langchain_community.tools.tavily_search import TavilySearchResults
from dotenv import load_dotenv
load_dotenv()

llm=init_chat_model("o4-mini",  model_provider="azure_openai",  configurable_fields=("temperature",), disabled_params={"parallel_tool_calls": None})

class PlanExecute(TypedDict):
    input: str
    plan: List[str]
    past_steps: Annotated[List[Tuple], operator.add]
    response: str

class Plan(BaseModel):
    """Plan to follow in future"""

    steps: List[str] = Field(
        description="different steps to follow, should be in sorted order"
    )
tools = [TavilySearchResults(max_results=3)]
planner_prompt ="""
You are a researcher.
For the given objective, come up with a simple step by step plan. 
This plan should involve individual tasks, that if executed correctly will yield the correct answer. Do not add any superfluous steps. 
The result of the final step should be the final answer. Make sure that each step has all the information needed - do not skip steps.
"""
prompt = ChatPromptTemplate.from_messages(
[
    ("system", planner_prompt), 
    ("placeholder", "{messages}"),
])

planner = prompt | llm.with_structured_output(Plan)
executor_prompt = "You are a helpful assistant."
agent_executor = create_react_agent(llm,tools, prompt=prompt)

user_input = """
MCP (Model Context Protocol) là gì
"""
response = planner.invoke(
            {
                "messages": [
                    ("user", user_input)
                ]
            }
        )
print(response)