commit initial code

Dockerfile

@@ -0,0 +1,16 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -0,0 +1,384 @@
+"""
+LangGraph Japanese Lesson Generator with Structured Output
+Two-Agent System with Native Structure Output from LLM
+"""
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, Field
+from typing import Optional, List
+import os
+from langchain_groq import ChatGroq
+from langgraph.graph import StateGraph, END
+from typing import TypedDict
+from dotenv import load_dotenv
+
+# ============ LOAD ENVIRONMENT ============
+load_dotenv()
+
+# ============ PYDANTIC BASE MODELS ============
+
+class VocabularyItem(BaseModel):
+    """Vocabulary item with all required fields"""
+    japanese: str = Field(..., description="Japanese word in Kanji/Hiragana/Katakana")
+    romaji: str = Field(..., description="Romanized version of the word")
+    meaning: str = Field(..., description="English meaning of the word")
+    example: str = Field(..., description="Example sentence using the word")
+
+
+class GrammarPoint(BaseModel):
+    """Grammar point with all required fields"""
+    pattern: str = Field(..., description="The grammar pattern (e.g., N1 は N2 です)")
+    explanation: str = Field(..., description="Detailed explanation of the pattern")
+    example: str = Field(..., description="Example sentence showing the pattern")
+    translation: str = Field(..., description="English translation of the example")
+
+
+class Question(BaseModel):
+    """Multiple choice question with all required fields"""
+    question: str = Field(..., description="The question text")
+    options: List[str] = Field(..., min_items=4, max_items=4, description="Exactly 4 answer options")
+    correctIndex: int = Field(..., ge=0, le=3, description="Index of correct answer (0-3)")
+
+
+class SubSection(BaseModel):
+    """Subsection with conversation, vocabulary, grammar, and questions"""
+    title: str = Field(..., description="Title of the subsection")
+    conversation: str = Field(..., description="Dialog conversation in format 'A: text\\nB: text'")
+    vocabularies: List[VocabularyItem] = Field(..., min_items=5, description="At least 5 vocabulary items")
+    grammarPoints: List[GrammarPoint] = Field(..., min_items=3, description="At least 3 grammar points")
+    questions: List[Question] = Field(..., min_items=4, max_items=5, description="4-5 questions")
+
+
+class Lesson(BaseModel):
+    """Complete lesson with all required sections"""
+    title: str = Field(..., description="Lesson title (English and Japanese)")
+    description: str = Field(..., description="Comprehensive lesson description")
+    color: str = Field(..., pattern="^#[0-9a-fA-F]{6}$", description="Hex color code")
+    subSections: List[SubSection] = Field(..., min_items=2, max_items=3, description="2-3 subsections")
+
+
+class OrganizedData(BaseModel):
+    """Output from organizer agent"""
+    lessonTitle: str = Field(..., description="Title of the lesson")
+    lessonDescription: str = Field(..., description="Description of the lesson")
+    subSections: List[dict] = Field(..., description="List of subsections to create")
+
+
+class LessonRequest(BaseModel):
+    """API request model"""
+    lesson_topic: str = Field(..., description="The lesson topic to generate")
+    additional_context: Optional[str] = Field(None, description="Additional context or requirements")
+
+
+# ============ STATE DEFINITIONS ============
+class State(TypedDict):
+    raw_input: str
+    organized_data: Optional[OrganizedData]
+    final_lesson: Optional[Lesson]
+    error: Optional[str]
+
+
+# ============ INITIALIZE LLM WITH STRUCTURE OUTPUT ============
+app = FastAPI()
+
+base_llm = ChatGroq(
+    model="llama-3.3-70b-versatile",
+    temperature=0.7,
+    api_key=os.getenv("GROQ_API_KEY")
+)
+
+# Create structured output versions
+organizer_llm = base_llm.with_structured_output(OrganizedData)
+generator_llm = base_llm.with_structured_output(Lesson)
+
+
+# ============ AGENT 1: ORGANIZER AGENT ============
+def organizer_agent(state: State) -> State:
+    """
+    First Agent: Organizes unstructured input data
+    Uses structured output to guarantee proper format
+    """
+    
+    organize_prompt = f"""You are a Japanese lesson content organizer. 
+Your job is to take unstructured user input about a Japanese lesson topic and organize it logically.
+
+User Input: {state['raw_input']}
+
+Analyze this and organize into a structured format:
+
+Requirements:
+1. Extract or create a clear Lesson Title
+2. Write a comprehensive Lesson Description (2-3 sentences)
+3. Determine 2-3 SubSections (typically progression from basic to complex)
+4. For each subsection, identify:
+   - Clear title
+   - Main topics/themes to cover
+   - Vocabulary themes (e.g., greetings, family, food)
+   - Relevant grammar patterns
+   - Number of questions (4-5)
+
+Think pedagogically about lesson progression. Be specific and detailed."""
+
+    try:
+        print("🔄 Organizer Agent processing...")
+        organized_result = organizer_llm.invoke(organize_prompt)
+        state["organized_data"] = organized_result
+        print("✅ Organizer Agent completed successfully")
+        return state
+    except Exception as e:
+        state["error"] = f"Organizer Agent Error: {str(e)}"
+        print(f"❌ Organizer Error: {e}")
+        return state
+
+
+# ============ AGENT 2: GENERATOR AGENT ============
+def generator_agent(state: State) -> State:
+    """
+    Second Agent: Generates complete lesson content
+    Uses structured output to guarantee exact schema compliance
+    """
+    
+    if state["error"]:
+        return state
+    
+    organized_data = state["organized_data"]
+    
+    generate_prompt = f"""You are an expert Japanese language teacher creating authentic, complete lesson content.
+
+Based on this lesson structure:
+Title: {organized_data.lessonTitle}
+Description: {organized_data.lessonDescription}
+
+SubSections needed:
+{chr(10).join([f"- {sub['title']}: {sub.get('topics', [])} | Vocabulary: {sub.get('vocabularyThemes', [])} | Grammar: {sub.get('grammarPatterns', [])} | Questions: {sub.get('questionCount', 4)}" for sub in organized_data.subSections])}
+
+Generate a COMPLETE Japanese lesson with:
+
+1. Title: Clear lesson name in English and Japanese
+2. Description: 2-3 sentence comprehensive overview  
+3. Color: Choose one from: #3498db, #e74c3c, #2ecc71, #f39c12, #9b59b6, #1abc9c, #e91e63, #00bcd4
+4. Create 2-3 subsections as specified
+
+FOR EACH SUBSECTION:
+- Title: Clear subsection name
+- Conversation: MUST be natural Japanese dialogue. Format: "A: [Japanese]\\nB: [Japanese]\\nA: [Japanese]\\nB: [Japanese]"
+  (Include at least 4 lines. Use REAL Japanese sentences.)
+- Vocabularies: Minimum 5-8 items per subsection
+  * japanese: ONLY Kanji/Hiragana/Katakana (e.g., "こんにちは")
+  * romaji: Romanized (e.g., "Konnichiwa")
+  * meaning: English translation
+  * example: Example sentence using the word
+- grammarPoints: EXACTLY 3-4 grammar patterns
+  * pattern: Grammar rule (e.g., "N1 は N2 です")
+  * explanation: Clear explanation
+  * example: Japanese sentence demonstrating it
+  * translation: English translation
+- questions: EXACTLY 4-5 multiple choice questions
+  * question: English question
+  * options: EXACTLY 4 answer choices
+  * correctIndex: Index of correct answer (0, 1, 2, or 3)
+
+Create authentic, educational content. Every field must be filled with real, useful content."""
+
+    try:
+        print("🔄 Generator Agent processing...")
+        lesson_result = generator_llm.invoke(generate_prompt)
+        state["final_lesson"] = lesson_result
+        print("✅ Generator Agent completed successfully")
+        print(f"✅ Generated lesson: {lesson_result.title}")
+        return state
+    except Exception as e:
+        state["error"] = f"Generator Agent Error: {str(e)}"
+        print(f"❌ Generator Error: {e}")
+        return state
+
+
+# ============ BUILD LANGGRAPH ============
+def build_graph():
+    """Create the LangGraph workflow"""
+    graph = StateGraph(State)
+    
+    # Add nodes
+    graph.add_node("organizer", organizer_agent)
+    graph.add_node("generator", generator_agent)
+    
+    # Add edges
+    graph.add_edge("organizer", "generator")
+    graph.add_edge("generator", END)
+    
+    # Set entry point
+    graph.set_entry_point("organizer")
+    
+    return graph.compile()
+
+
+workflow = build_graph()
+
+
+# ============ API ENDPOINT ============
+@app.post("/api/generate-lesson")
+async def generate_lesson(request: LessonRequest):
+    """
+    Main API endpoint to generate Japanese lessons
+    
+    Input: Raw lesson topic/content
+    Process: Two-agent LangGraph workflow with structured output
+    Output: Strictly validated lesson JSON following exact schema
+    """
+    
+    try:
+        if not request.lesson_topic or request.lesson_topic.strip() == "":
+            raise HTTPException(status_code=400, detail="lesson_topic cannot be empty")
+        
+        print(f"\n🚀 Starting lesson generation for: {request.lesson_topic[:50]}...")
+        
+        # Prepare initial state
+        initial_state: State = {
+            "raw_input": request.lesson_topic,
+            "organized_data": None,
+            "final_lesson": None,
+            "error": None
+        }
+        
+        # Run the workflow
+        result = workflow.invoke(initial_state)
+        
+        # Check for errors
+        if result.get("error"):
+            print(f"⚠️ Workflow Error: {result['error']}")
+            raise HTTPException(status_code=500, detail=result["error"])
+        
+        if not result.get("final_lesson"):
+            raise HTTPException(status_code=500, detail="Failed to generate lesson")
+        
+        print("✅ Lesson generation completed successfully!")
+        
+        # Return as JSON
+        return result["final_lesson"].model_dump()
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"❌ API Error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+
+# ============ HEALTH CHECK ENDPOINT ============
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "message": "LangGraph Lesson Generator with Structured Output is running"
+    }
+
+
+# ============ EXAMPLE ENDPOINT ============
+@app.get("/example")
+async def example():
+    """Return example of expected output format"""
+    example_lesson = {
+        "title": "Self Introduction (じこしょうかい)",
+        "description": "Learn greetings, how to introduce yourself, say your age and birthday, and talk about your family.",
+        "color": "#3498db",
+        "subSections": [
+            {
+                "title": "Hello & Basic Introduction",
+                "conversation": "A: こんにちは!\\nB: こんにちは。はじめまして。\\nA: わたしはキムです。かんこくからきました。\\nB: よろしくおねがいします。",
+                "vocabularies": [
+                    {
+                        "japanese": "こんにちは",
+                        "romaji": "Konnichiwa",
+                        "meaning": "Hello / Good afternoon",
+                        "example": "こんにちは!"
+                    },
+                    {
+                        "japanese": "はじめまして",
+                        "romaji": "Hajimemashite",
+                        "meaning": "Nice to meet you (first time)",
+                        "example": "はじめまして。"
+                    },
+                    {
+                        "japanese": "わたし",
+                        "romaji": "Watashi",
+                        "meaning": "I / Me",
+                        "example": "わたしは学生です。"
+                    },
+                    {
+                        "japanese": "です",
+                        "romaji": "Desu",
+                        "meaning": "to be (polite)",
+                        "example": "わたしは学生です。"
+                    },
+                    {
+                        "japanese": "からきました",
+                        "romaji": "Kara kimashita",
+                        "meaning": "Came from",
+                        "example": "バングラデシュからきました。"
+                    },
+                    {
+                        "japanese": "よろしくおねがいします",
+                        "romaji": "Yoroshiku onegaishimasu",
+                        "meaning": "Please take care of me",
+                        "example": "よろしくおねがいします。"
+                    },
+                    {
+                        "japanese": "かんこく",
+                        "romaji": "Kankoku",
+                        "meaning": "Korea",
+                        "example": "かんこくからきました。"
+                    }
+                ],
+                "grammarPoints": [
+                    {
+                        "pattern": "N は N です",
+                        "explanation": "Used to state what something/someone is.",
+                        "example": "わたしは学生です。",
+                        "translation": "I am a student."
+                    },
+                    {
+                        "pattern": "N は N から来ました",
+                        "explanation": "Used to say where someone came from.",
+                        "example": "わたしはバングラデシュからきました。",
+                        "translation": "I came from Bangladesh."
+                    },
+                    {
+                        "pattern": "よろしくおねがいします",
+                        "explanation": "Polite greeting used when meeting someone for the first time.",
+                        "example": "はじめまして。よろしくおねがいします。",
+                        "translation": "Nice to meet you. Please take care of me."
+                    }
+                ],
+                "questions": [
+                    {
+                        "question": "How do you say 'Hello' in Japanese?",
+                        "options": ["さようなら", "こんにちは", "おはよう", "おやすみなさい"],
+                        "correctIndex": 1
+                    },
+                    {
+                        "question": "What does 'はじめまして' mean?",
+                        "options": ["Goodbye", "Nice to meet you", "Thank you", "Good morning"],
+                        "correctIndex": 1
+                    },
+                    {
+                        "question": "How would you say you came from Bangladesh?",
+                        "options": ["バングラデシュです。", "バングラデシュからきました。", "バングラデシュへいきます。", "バングラデシュで働きます。"],
+                        "correctIndex": 1
+                    },
+                    {
+                        "question": "Which sentence is correct for 'I am a student'?",
+                        "options": ["わたしがくせ��です。", "わたしは学生です。", "学生はわたしです。", "わたしを学生です。"],
+                        "correctIndex": 1
+                    }
+                ]
+            }
+        ]
+    }
+    return example_lesson
+
+
+# ============ RUN SERVER ============
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -0,0 +1,7 @@
+fastapi
+uvicorn[standard]
+langchain
+langchain-groq
+pydantic
+langgraph
+python-dotenv