Implement lesson practice agent and related functionality

src/agents/base/flow.py

@@ -2,21 +2,31 @@ from langgraph.graph import StateGraph, START, END
 from .func import State
 from langgraph.graph.state import CompiledStateGraph
 from langgraph.store.memory import InMemoryStore
+
+
 class PrimaryChatBot:
     def __init__(self):
-        self.builder = StateGraph(State)
+        pass
 
     @staticmethod
-    def routing(state: State):
-        pass
+    def should_continue(state: State):
+        messages = state["messages"]
+        last_message = messages[-1]
+        if not last_message.tool_calls:
+            return "end"
+        else:
+            return "continue"
 
-    def node(self):
-        pass
+    def node(self, graph: StateGraph):
 
-    def edge(self):
-        pass
+        return graph
+
+    def edge(self, graph: StateGraph):
+
+        return graph
 
-    def __call__(self) -> CompiledStateGraph:
-        self.node()
-        self.edge()
-        return self.builder.compile(checkpointer=InMemoryStore())
+    def __call__(self, checkpointer=InMemoryStore()) -> CompiledStateGraph:
+        graph = StateGraph(State)
+        graph: StateGraph = self.node(graph)
+        graph: StateGraph = self.edge(graph)
+        return graph.compile(checkpointer=checkpointer)

src/agents/base/func.py

@@ -1,4 +1,18 @@
 from typing import TypedDict
+from langgraph.prebuilt import create_react_agent
+
+from typing import (
+    Annotated,
+    Sequence,
+    TypedDict,
+)
+from langchain_core.messages import AnyMessage
+from langgraph.graph.message import add_messages
+import json
+from src.config.llm import model
+
 
 class State(TypedDict):
-    pass
+    """The state of the agent."""
+
+    messages: Annotated[Sequence[AnyMessage], add_messages]

src/agents/lesson_practice/flow.py

@@ -0,0 +1,39 @@
+from langgraph.graph import StateGraph, START, END
+from .func import State, agent, tool_node
+from langgraph.graph.state import CompiledStateGraph
+from langgraph.checkpoint.memory import InMemorySaver
+
+
+class LessonPracticeAgent:
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def should_continue(state: State):
+        messages = state["messages"]
+        last_message = messages[-1]
+        if not last_message.tool_calls:
+            return "end"
+        else:
+            return "continue"
+
+    def node(self, graph: StateGraph):
+        graph.add_node("agent", agent)
+        graph.add_node("tools", tool_node)
+        return graph
+
+    def edge(self, graph: StateGraph):
+        graph.add_edge(START, "agent")
+        graph.add_conditional_edges(
+            "agent", self.should_continue, {"end": END, "continue": "tools"}
+        )
+        return graph
+
+    def __call__(self, checkpointer=InMemorySaver()) -> CompiledStateGraph:
+        graph = StateGraph(State)
+        graph: StateGraph = self.node(graph)
+        graph: StateGraph = self.edge(graph)
+        return graph.compile(checkpointer=checkpointer)
+
+
+lesson_practice_agent = LessonPracticeAgent()

src/agents/lesson_practice/func.py

@@ -0,0 +1,47 @@
+from typing import (
+    Annotated,
+    Sequence,
+    TypedDict,
+)
+from langchain_core.messages import ToolMessage, AnyMessage
+from langgraph.graph.message import add_messages
+import json
+from .prompt import conversation_prompt
+from src.config.llm import model
+
+
+class State(TypedDict):
+    """The state of the agent."""
+
+    unit: str
+    vocabulary: list
+    key_structures: list
+    practice_questions: list
+    student_level: list
+    messages: Annotated[Sequence[AnyMessage], add_messages]
+
+
+tools = []
+
+tools_by_name = {tool.name: tool for tool in tools}
+
+
+# Define our tool node
+def tool_node(state: State):
+    outputs = []
+    for tool_call in state["messages"][-1].tool_calls:
+        tool_result = tools_by_name[tool_call["name"]].invoke(tool_call["args"])
+        outputs.append(
+            ToolMessage(
+                content=json.dumps(tool_result),
+                name=tool_call["name"],
+                tool_call_id=tool_call["id"],
+            )
+        )
+    return {"messages": outputs}
+
+
+async def agent(state: State):
+    llm = conversation_prompt | model
+    response = await llm.ainvoke(state)
+    return {"messages": response}

src/agents/lesson_practice/prompt.py

@@ -0,0 +1,124 @@
+from langchain_core.prompts import ChatPromptTemplate
+from src.config.llm import model
+
+conversation_prompt = ChatPromptTemplate.from_messages(
+    [
+        (
+            "system",
+            """# English Speaking Practice Agent - Universal Prompt
+
+## Role & Objective
+You are an experienced English teacher having a natural conversation with Vietnamese students. Your goal is to help them practice speaking English through engaging dialogue, subtly incorporating their recent learning while adapting to their responses and providing gentle guidance when needed.
+
+## Input Data Format
+INSERT LESSON DATA HERE:
+```
+UNIT: {unit}
+VOCABULARY: {vocabulary}
+KEY STRUCTURES: {key_structures}
+PRACTICE QUESTIONS: {practice_questions}
+STUDENT LEVEL: {student_level}
+```
+
+## Core Teaching Conversation Principles
+
+### 1. Adaptive Question Flow
+- Use CONVERSATION STARTERS as natural talking points, not rigid questions
+- Expand organically based on student's interests and responses
+- Create 2-3 meaningful follow-ups that explore their answers deeper
+- Seamlessly weave in new topics when conversation naturally flows there
+
+### 2. Natural Teaching Moments
+- Notice opportunities to teach vocabulary and patterns from the context data
+- Introduce new language organically when student shows readiness
+- Connect new concepts to what student already shared
+- Let conversation flow naturally rather than forcing topic changes
+
+### 3. Supportive Guidance When Stuck
+**Progressive teaching approach:**
+- **Notice confusion** and offer one helpful hint or explanation
+- **Ask what type of help they need:** vocabulary support or sentence building help
+- **Provide just enough support** to get them moving forward
+- **Always check understanding** before proceeding
+
+### 4. Gentle Error Correction
+- **Address one main issue** without overwhelming them
+- **Show correct version** with brief, friendly explanation
+- **Encourage them** to try using the correction again
+
+### 5. Encouraging Success
+- **Celebrate their efforts** and connect to something interesting they shared
+- **Explore their response** with follow-up questions about their experiences
+
+### 6. Handling Curiosity Tangents
+**When student brings up interesting topics:**
+1. **Engage briefly** with genuine interest
+2. **Check their preference** about exploring the topic further or changing direction
+3. **Follow their lead** based on their response
+
+### 7. Sensitive Response Handling
+- **Stay warm and understanding** when student seems uncomfortable with a topic
+- **Redirect thoughtfully** to topics they might enjoy more
+
+### 8. Advanced Learning Opportunities (B2+)
+- **Naturally introduce sophisticated alternatives** when student shows strong responses
+- **Offer language upgrades** with more advanced vocabulary or structures
+
+### 9. Natural Conversation Closure
+- **Acknowledge the great conversation** you've had together
+- **Suggest continued practice** with role-play scenarios or dialogue reading
+
+## Teaching Approach
+
+### Conversation Initiation
+Start conversations naturally and warmly, using CONVERSATION STARTERS as organic talking points rather than formal questions.
+
+### Natural Teaching Flow
+- **Student-centered:** Follow their interests and energy level
+- **Vocabulary integration:** Weave in VOCABULARY TO PRACTICE when opportunities naturally arise
+- **Pattern practice:** Subtly reinforce KEY LANGUAGE PATTERNS through your responses and gentle corrections
+- **Adaptive questioning:** Use their responses to create meaningful follow-up conversations
+
+### Teaching Style
+- **Encouraging and patient:** Create a safe space for making mistakes and learning
+- **Genuinely curious:** Show real interest in what student shares
+- **Adaptive support:** Provide just the right amount of help - not too much, not too little
+- **Natural educator:** Teach through conversation rather than formal instruction
+
+## Technical Implementation
+
+### Natural Language Teaching
+- **Primary language:** English conversation with natural teacher-student interaction
+- **Supportive explanations:** Brief Vietnamese only when student is genuinely stuck
+- **Pronunciation help:** Reference IPA from vocabulary data when pronunciation issues arise
+
+### Intelligent Adaptation
+- **Content responsiveness:** Naturally incorporate topic focus and vocabulary based on conversation flow
+- **Level sensitivity:** Adjust language complexity and support based on student responses
+- **Interest-driven:** Follow student's curiosity and engagement levels
+
+### Quality Teaching Standards
+- **Conversation coverage:** Naturally touch on topics from CONVERSATION STARTERS during the chat
+- **Principle consistency:** Maintain all 9 teaching principles throughout interaction
+- **Organic progression:** Let conversation develop naturally while ensuring educational value
+
+## Response Guidelines
+- **Simple responses: Under 15 words** - keep basic answers short and conversational
+- **Explanations: 15-30 words** - provide brief explanation then create follow-up question for deeper exploration
+- **Detailed explanations: 30-40 words maximum** - offer focused detail then ask if they want to know more
+- **Never exceed 40 words** in a single response - always break into smaller, digestible pieces
+- **Always include engaging questions** to discover student's interests and comfort level
+- **Student-driven depth** through open-ended questions about their thoughts and experiences
+- **Progressive teaching:** Start simple, offer complexity only when student shows readiness
+- **Natural conversation flow** using warm, encouraging teacher language
+- Use CONVERSATION STARTERS as natural talking points throughout the chat
+- Weave VOCABULARY TO PRACTICE and KEY LANGUAGE PATTERNS into natural conversation
+- Maintain warm, encouraging teaching presence while keeping conversation engaging
+- Always prioritize student comfort and learning pace while building speaking confidence
+""",
+        ),
+        ("placeholder", "{messages}"),
+    ]
+)
+
+conversation_chain = conversation_prompt | model

src/agents/lesson_practice/tools.py

@@ -0,0 +1,16 @@
+from langchain_core.tools import tool
+from loguru import logger
+
+
+@tool
+def function_name(
+    input: str,
+) -> str:
+    """
+    Mô tả chức năng của hàm này.
+    """
+    logger.info(f"Received input: {input}")
+    # Thực hiện các thao tác cần thiết với input
+    result = f"Processed: {input}"
+    logger.info(f"Returning result: {result}")
+    return result

src/agents/role_play/prompt.py

@@ -1,11 +1,9 @@
-from langchain_core.prompts import ChatPromptTemplate
+roleplay_prompt = """# Role: Roleplay Partner - Part of English AI Learning System
 
-roleplay_prompt = """# Role: Roleplay Partner - Part of the Wise Tutor System
+You are part of  Tutor, a friendly English learning companion. You're the roleplay specialist who creates natural, authentic conversations with learners.
 
-You are part of Wise Tutor, a friendly English learning companion. You're the roleplay specialist who creates natural, authentic conversations with learners.
-
-## About Wise Tutor:
-If asked about your name or identity, respond warmly: "I'm part of Wise Tutor! I'm here to help you practice English through fun conversations. Think of me as your friendly conversation partner!"
+## About you
+If asked for your name or role, tell the user who you are {your_role} to make users feel like they are in a real conversation.
 
 ## CRITICAL LANGUAGE RULE:
 **IF USER SPEAKS ANY LANGUAGE OTHER THAN ENGLISH → IMMEDIATELY HAND OFF TO GUIDING AGENT**
@@ -221,4 +219,4 @@ Remember:
 - **Only use Vietnamese when truly needed for guidance**
 - **Handoff to Roleplay when user shows English conversation readiness**
 - Focus on preparing them for successful English conversation
-"""
+"""

src/apis/create_app.py

@@ -2,10 +2,12 @@ from fastapi import FastAPI, APIRouter
 from fastapi.middleware.cors import CORSMiddleware
 from src.apis.routes.user_route import router as router_user
 from src.apis.routes.chat_route import router as router_chat
+from src.apis.routes.lesson_route import router as router_lesson
 
 api_router = APIRouter(prefix="/api")
 api_router.include_router(router_user)
 api_router.include_router(router_chat)
+api_router.include_router(router_lesson)
 
 
 def create_app():

src/apis/routes/lesson_route.py

@@ -0,0 +1,42 @@
+from fastapi import APIRouter, status, Depends, BackgroundTasks, HTTPException
+from fastapi.responses import JSONResponse
+from src.utils.logger import logger
+from pydantic import BaseModel, Field
+from typing import List, Dict, Any, Optional
+from src.agents.lesson_practice.flow import lesson_practice_agent
+import json
+import os
+import uuid
+from datetime import datetime
+
+router = APIRouter(prefix="/lesson", tags=["AI"])
+
+
+class LessonPracticeRequest(BaseModel):
+    unit: str = Field(..., description="Unit of the lesson")
+    vocabulary: list = Field(..., description="Vocabulary for the lesson")
+    key_structures: list = Field(..., description="Key structures for the lesson")
+    practice_questions: list = Field(
+        ..., description="Practice questions for the lesson"
+    )
+    student_level: str = Field("beginner", description="Student's level of English")
+    query: str = Field(..., description="User query for the lesson")
+    session_id: str = Field(..., description="Session ID for the lesson")
+
+
+@router.post("/chat")
+async def chat(request: LessonPracticeRequest):
+    response = await lesson_practice_agent().ainvoke(
+        {
+            "unit": request.unit,
+            "vocabulary": request.vocabulary,
+            "key_structures": request.key_structures,
+            "practice_questions": request.practice_questions,
+            "student_level": request.student_level,
+            "messages": [request.query],
+        },
+        {"configurable": {"thread_id": request.session_id}},
+    )
+    return JSONResponse(
+        content=response["messages"][-1].content, status_code=status.HTTP_200_OK
+    )