Upload folder using huggingface_hub

README.md

@@ -5,12 +5,12 @@ app_file: app.py
 requirements: requirements.txt
 python: 3.10
 sdk: gradio
-sdk_version: 5.34.2
+sdk_version: 5.38.1
 ---
 
 # AnkiGen - Anki Card Generator
 
-AnkiGen is a Gradio-based web application that generates high-quality Anki-compatible CSV and `.apkg` deck files using an advanced multi-agent system powered by OpenAI Agents. The system employs specialized generator agents, quality assessment judges, and enhancement agents to create superior flashcards.
+AnkiGen is a Gradio-based web application that generates high-quality Anki-compatible CSV and `.apkg` deck files using the OpenAI Agents SDK. The system leans on a specialized subject expert agent plus a lightweight self-review step to create solid flashcards without an expensive multi-agent cascade.
 
 ## Features
 
@@ -113,12 +113,10 @@ The codebase uses a sophisticated multi-agent architecture powered by the OpenAI
 
 -   `app.py`: Main Gradio application interface and event handling.
 -   `ankigen_core/`: Directory containing the core logic modules:
-    -   `agents/`: **OpenAI Agents system implementation**:
-        -   `base.py`: Base agent wrapper and configuration classes
-        -   `generators.py`: Specialized generator agents (SubjectExpertAgent, PedagogicalAgent, ContentStructuringAgent)
-        -   `judges.py`: Quality assessment agents (ContentAccuracyJudge, PedagogicalJudge, ClarityJudge, etc.)
-        -   `enhancers.py`: Revision and enhancement agents for card improvement
-        -   `integration.py`: AgentOrchestrator for coordinating the entire agent system
+        -   `agents/`: **OpenAI Agents system implementation**:
+            -   `base.py`: Base agent wrapper and configuration classes
+            -   `generators.py`: SubjectExpertAgent for primary card creation
+            -   `integration.py`: AgentOrchestrator for orchestrating generation + self-review
         -   `config.py`: Agent configuration management
         -   `schemas.py`: Pydantic schemas for structured agent outputs
         -   `templates/`: Jinja2 templates for agent prompts
@@ -139,26 +137,11 @@ The codebase uses a sophisticated multi-agent architecture powered by the OpenAI
 
 AnkiGen employs a sophisticated multi-agent system built on the OpenAI Agents SDK that ensures high-quality flashcard generation through specialized roles and quality control:
 
-### Generator Agents
-- **SubjectExpertAgent**: Provides domain-specific expertise for accurate content creation
-- **PedagogicalAgent**: Ensures cards follow effective learning principles and memory techniques
-- **ContentStructuringAgent**: Optimizes card structure, formatting, and information hierarchy
-
-### Quality Assurance Judges
-- **ContentAccuracyJudge**: Verifies factual correctness and subject matter accuracy
-- **PedagogicalJudge**: Evaluates learning effectiveness and educational value
-- **ClarityJudge**: Assesses readability, comprehension, and clear communication
-- **TechnicalJudge**: Reviews technical accuracy for specialized subjects
-- **CompletenessJudge**: Ensures comprehensive coverage without information gaps
-
-### Enhancement Agents
-- **RevisionAgent**: Identifies areas for improvement based on judge feedback
-- **EnhancementAgent**: Implements refinements and optimizations to failed cards
+### Generator Agent
+- **SubjectExpertAgent**: Provides domain-specific expertise for accurate content creation, followed by a single lightweight quality review that can revise or drop weak cards.
 
 ### Orchestration
-- **GenerationCoordinator**: Manages the card generation workflow and agent handoffs
-- **JudgeCoordinator**: Coordinates quality assessment across all judge agents
-- **AgentOrchestrator**: Main system controller that initializes and manages the entire agent ecosystem
+- **AgentOrchestrator**: Main system controller that initializes the simplified agent pipeline and runs self-review before returning cards.
 
 This architecture ensures that every generated flashcard undergoes rigorous quality control and iterative improvement, resulting in superior learning materials.
 

ankigen_core/agents/__init__.py

@@ -1,37 +1,12 @@
 # Agent system for AnkiGen agentic workflows
 
 from .base import BaseAgentWrapper, AgentConfig
-from .generators import (
-    SubjectExpertAgent,
-    PedagogicalAgent,
-    ContentStructuringAgent,
-    GenerationCoordinator,
-)
-from .judges import (
-    ContentAccuracyJudge,
-    PedagogicalJudge,
-    ClarityJudge,
-    TechnicalJudge,
-    CompletenessJudge,
-    JudgeCoordinator,
-)
-from .enhancers import RevisionAgent, EnhancementAgent
+from .generators import SubjectExpertAgent
 from .config import AgentConfigManager
 
 __all__ = [
     "BaseAgentWrapper",
     "AgentConfig",
     "SubjectExpertAgent",
-    "PedagogicalAgent",
-    "ContentStructuringAgent",
-    "GenerationCoordinator",
-    "ContentAccuracyJudge",
-    "PedagogicalJudge",
-    "ClarityJudge",
-    "TechnicalJudge",
-    "CompletenessJudge",
-    "JudgeCoordinator",
-    "RevisionAgent",
-    "EnhancementAgent",
     "AgentConfigManager",
 ]

ankigen_core/agents/base.py

@@ -62,6 +62,11 @@ class BaseAgentWrapper:
     async def initialize(self):
         """Initialize the OpenAI agent with structured output support"""
         try:
+            # Set the default OpenAI client for the agents SDK
+            from agents import set_default_openai_client
+
+            set_default_openai_client(self.openai_client, use_for_tracing=False)
+
             # Create model settings with temperature
             model_settings = ModelSettings(temperature=self.config.temperature)
 
@@ -102,30 +107,51 @@ class BaseAgentWrapper:
         if not self.agent:
             await self.initialize()
 
+        # Add context to the user input if provided
+        enhanced_input = user_input
+        if context is not None:
+            context_str = "\n".join([f"{k}: {v}" for k, v in context.items()])
+            enhanced_input = f"{user_input}\n\nContext:\n{context_str}"
+
+        # Execute the agent using Runner.run() with retry logic
+        if self.agent is None:
+            raise ValueError("Agent not initialized")
+
+        logger.info(f"🤖 EXECUTING AGENT: {self.config.name}")
+        logger.info(f"📝 INPUT: {enhanced_input[:200]}...")
+
+        import time
+
+        start_time = time.time()
+
+        for attempt in range(self.config.retry_attempts):
+            try:
+                result = await asyncio.wait_for(
+                    Runner.run(
+                        starting_agent=self.agent,
+                        input=enhanced_input,
+                    ),
+                    timeout=self.config.timeout,
+                )
+                break
+            except asyncio.TimeoutError:
+                if attempt < self.config.retry_attempts - 1:
+                    logger.warning(
+                        f"Agent {self.config.name} timed out (attempt {attempt + 1}/{self.config.retry_attempts}), retrying..."
+                    )
+                    continue
+                else:
+                    logger.error(
+                        f"Agent {self.config.name} timed out after {self.config.retry_attempts} attempts"
+                    )
+                    raise
+
         try:
-            # Add context to the user input if provided
-            enhanced_input = user_input
-            if context is not None:
-                context_str = "\n".join([f"{k}: {v}" for k, v in context.items()])
-                enhanced_input = f"{user_input}\n\nContext:\n{context_str}"
-
-            # Execute the agent using Runner.run()
-            if self.agent is None:
-                raise ValueError("Agent not initialized")
-
-            logger.info(f"🤖 EXECUTING AGENT: {self.config.name}")
-            logger.info(f"📝 INPUT: {enhanced_input[:200]}...")
-
-            result = await asyncio.wait_for(
-                Runner.run(
-                    starting_agent=self.agent,
-                    input=enhanced_input,
-                ),
-                timeout=self.config.timeout,
+            execution_time = time.time() - start_time
+            logger.info(
+                f"Agent {self.config.name} executed successfully in {execution_time:.2f}s"
             )
 
-            logger.info(f"Agent {self.config.name} executed successfully")
-
             # Extract usage information from raw_responses
             total_usage = {
                 "input_tokens": 0,

ankigen_core/agents/config.py

@@ -54,7 +54,6 @@ class AgentConfigManager:
         self.configs: Dict[str, AgentConfig] = {}
         self.prompt_templates: Dict[str, AgentPromptTemplate] = {}
 
-        # Set up Jinja2 environment with templates directory
         template_dir = Path(__file__).parent / "templates"
         self.jinja_env = Environment(loader=FileSystemLoader(template_dir))
         self._load_default_configs()
@@ -66,18 +65,15 @@ class AgentConfigManager:
         logger.info(f"Updated model overrides: {model_overrides}")
 
     def update_template_vars(self, template_vars: Dict[str, Any]):
-        """Update template variables and regenerate configs"""
-        self.template_vars = template_vars
-        self._load_default_configs()
-        logger.info(f"Updated template variables: {template_vars}")
+        logger.info(
+            "Template vars are no longer used in the simplified agent pipeline."
+        )
 
     def _load_default_configs(self):
         """Load all default configurations from Jinja templates"""
         try:
             self._load_configs_from_template("generators.j2")
-            self._load_configs_from_template("judges.j2")
-            self._load_configs_from_template("enhancers.j2")
-            self._load_prompt_templates_from_template("prompts.j2")
+            self.prompt_templates.clear()
             logger.info(
                 f"Loaded {len(self.configs)} agent configurations from Jinja templates"
             )
@@ -96,17 +92,6 @@ class AgentConfigManager:
             # Default models for each agent type
             default_models = {
                 "subject_expert_model": "gpt-4.1",
-                "pedagogical_agent_model": "gpt-4.1-nano",
-                "content_structuring_model": "gpt-4.1-nano",
-                "generation_coordinator_model": "gpt-4.1",
-                "content_accuracy_judge_model": "gpt-4.1-nano",
-                "pedagogical_judge_model": "gpt-4.1-nano",
-                "clarity_judge_model": "gpt-4.1-nano",
-                "technical_judge_model": "gpt-4.1-nano",
-                "completeness_judge_model": "gpt-4.1-nano",
-                "judge_coordinator_model": "gpt-4.1",
-                "revision_agent_model": "gpt-4.1",
-                "enhancement_agent_model": "gpt-4.1",
             }
 
             # Simple mapping: agent_name -> agent_name_model
@@ -140,29 +125,6 @@ class AgentConfigManager:
         except Exception as e:
             logger.error(f"Failed to load configs from template {template_name}: {e}")
 
-    def _load_prompt_templates_from_template(self, template_name: str):
-        """Load prompt templates from a Jinja template"""
-        try:
-            template = self.jinja_env.get_template(template_name)
-
-            # Render with current template variables
-            rendered_json = template.render(**self.template_vars)
-            template_data = json.loads(rendered_json)
-
-            # Create AgentPromptTemplate objects
-            for template_name, template_info in template_data.items():
-                prompt_template = AgentPromptTemplate(
-                    system_prompt=template_info.get("system_prompt", ""),
-                    user_prompt_template=template_info.get("user_prompt_template", ""),
-                    variables=template_info.get("variables", {}),
-                )
-                self.prompt_templates[template_name] = prompt_template
-
-        except Exception as e:
-            logger.error(
-                f"Failed to load prompt templates from template {template_name}: {e}"
-            )
-
     def get_agent_config(self, agent_name: str) -> Optional[AgentConfig]:
         """Get configuration for a specific agent"""
         return self.configs.get(agent_name)

ankigen_core/agents/generators.py

@@ -1,18 +1,60 @@
 # Specialized generator agents for card generation
 
 import json
-from typing import List, Dict, Any, Optional
-from datetime import datetime
+from typing import List, Dict, Any, Optional, Tuple
 
 from openai import AsyncOpenAI
 
 from ankigen_core.logging import logger
 from ankigen_core.models import Card, CardFront, CardBack
-from .base import BaseAgentWrapper
+from .base import BaseAgentWrapper, AgentConfig
 from .config import get_config_manager
 from .schemas import CardsGenerationSchema
 
 
+def card_dict_to_card(
+    card_data: Dict[str, Any],
+    default_topic: str,
+    default_subject: str,
+) -> Card:
+    """Convert a dictionary representation of a card into a Card object."""
+
+    if not isinstance(card_data, dict):
+        raise ValueError("Card payload must be a dictionary")
+
+    front_data = card_data.get("front")
+    back_data = card_data.get("back")
+
+    if not isinstance(front_data, dict) or "question" not in front_data:
+        raise ValueError("Card front must include a question field")
+    if not isinstance(back_data, dict) or "answer" not in back_data:
+        raise ValueError("Card back must include an answer field")
+
+    metadata = card_data.get("metadata", {}) or {}
+    if not isinstance(metadata, dict):
+        metadata = {}
+
+    subject = metadata.get("subject") or default_subject or "general"
+    topic = metadata.get("topic") or default_topic or "General Concepts"
+
+    card = Card(
+        card_type=str(card_data.get("card_type", "basic")),
+        front=CardFront(question=str(front_data.get("question", ""))),
+        back=CardBack(
+            answer=str(back_data.get("answer", "")),
+            explanation=str(back_data.get("explanation", "")),
+            example=str(back_data.get("example", "")),
+        ),
+        metadata=metadata,
+    )
+
+    if card.metadata is not None:
+        card.metadata.setdefault("subject", subject)
+        card.metadata.setdefault("topic", topic)
+
+    return card
+
+
 class SubjectExpertAgent(BaseAgentWrapper):
     """Subject matter expert agent for domain-specific card generation"""
 
@@ -42,21 +84,95 @@ class SubjectExpertAgent(BaseAgentWrapper):
     async def generate_cards(
         self, topic: str, num_cards: int = 5, context: Optional[Dict[str, Any]] = None
     ) -> List[Card]:
-        """Generate flashcards for a given topic"""
+        """Generate flashcards for a given topic with automatic batching for large requests"""
         try:
-            user_input = f"Generate {num_cards} flashcards for the topic: {topic}"
-            if context:
-                user_input += f"\n\nAdditional context: {context}"
+            # Use batching for large numbers of cards to avoid LLM limitations
+            batch_size = 10  # Generate max 10 cards per batch
+            all_cards = []
+            total_usage = {"total_tokens": 0, "input_tokens": 0, "output_tokens": 0}
+
+            cards_remaining = num_cards
+            batch_num = 1
+
+            logger.info(
+                f"Generating {num_cards} cards for topic '{topic}' using {((num_cards - 1) // batch_size) + 1} batches"
+            )
+
+            # Track card topics from previous batches to avoid duplication
+            previous_card_topics = []
+
+            while cards_remaining > 0:
+                cards_in_this_batch = min(batch_size, cards_remaining)
+
+                logger.info(
+                    f"Generating batch {batch_num}: {cards_in_this_batch} cards"
+                )
+
+                # Reset agent for each batch to avoid conversation history accumulation
+                self.agent = None
+                await self.initialize()
 
-            response, usage = await self.execute(user_input, context)
+                user_input = (
+                    f"Generate {cards_in_this_batch} flashcards for the topic: {topic}"
+                )
+                if context:
+                    user_input += f"\n\nAdditional context: {context}"
+
+                # Add previous topics to avoid repetition instead of full conversation history
+                if previous_card_topics:
+                    topics_summary = ", ".join(
+                        previous_card_topics[-20:]
+                    )  # Last 20 topics to keep it manageable
+                    user_input += f"\n\nAvoid creating cards about these already covered topics: {topics_summary}"
+
+                if batch_num > 1:
+                    user_input += f"\n\nThis is batch {batch_num} of cards. Ensure these cards cover different aspects of the topic."
+
+                response, usage = await self.execute(user_input, context)
+
+                # Accumulate usage information
+                if usage:
+                    for key in total_usage:
+                        total_usage[key] += usage.get(key, 0)
+
+                batch_cards = self._parse_cards_response(response, topic)
+                all_cards.extend(batch_cards)
+
+                # Extract topics from generated cards to avoid duplication in next batch
+                for card in batch_cards:
+                    if hasattr(card, "front") and card.front and card.front.question:
+                        # Extract key terms from the question for deduplication
+                        question_words = card.front.question.lower().split()
+                        key_terms = [word for word in question_words if len(word) > 3][
+                            :3
+                        ]  # First 3 meaningful words
+                        if key_terms:
+                            previous_card_topics.append(" ".join(key_terms))
+
+                cards_remaining -= len(batch_cards)
+                batch_num += 1
+
+                logger.info(
+                    f"Batch {batch_num-1} generated {len(batch_cards)} cards. {cards_remaining} cards remaining."
+                )
+
+                # Safety check to prevent infinite loops
+                if len(batch_cards) == 0:
+                    logger.warning(
+                        f"No cards generated in batch {batch_num-1}, stopping generation"
+                    )
+                    break
 
-            # Log usage information
-            if usage and usage.get("total_tokens", 0) > 0:
+            # Log final usage information
+            if total_usage.get("total_tokens", 0) > 0:
                 logger.info(
-                    f"💰 Token Usage: {usage['total_tokens']} tokens (Input: {usage['input_tokens']}, Output: {usage['output_tokens']})"
+                    f"💰 Total Token Usage: {total_usage['total_tokens']} tokens (Input: {total_usage['input_tokens']}, Output: {total_usage['output_tokens']})"
                 )
 
-            return self._parse_cards_response(response, topic)
+            logger.info(
+                f"✅ Generated {len(all_cards)} cards total across {batch_num-1} batches for topic '{topic}'"
+            )
+            return all_cards
 
         except Exception as e:
             logger.error(f"Card generation failed: {e}")
@@ -148,65 +264,17 @@ Return your response as a JSON object with this structure:
             cards = []
             for i, card_data in enumerate(card_data_list):
                 try:
-                    # Handle both Pydantic models and dictionaries
-                    if hasattr(card_data, "front"):
-                        # Pydantic model
-                        front_data = card_data.front
-                        back_data = card_data.back
-                        metadata = card_data.metadata
-                        card_type = card_data.card_type
-                    else:
-                        # Dictionary
-                        if "front" not in card_data or "back" not in card_data:
-                            logger.warning(f"Skipping card {i}: missing front or back")
-                            continue
-                        front_data = card_data["front"]
-                        back_data = card_data["back"]
-                        metadata = card_data.get("metadata", {})
-                        card_type = card_data.get("card_type", "basic")
-
-                    # Extract question and answer
-                    if hasattr(front_data, "question"):
-                        question = front_data.question
-                    else:
-                        question = front_data.get("question", "")
-
-                    if hasattr(back_data, "answer"):
-                        answer = back_data.answer
-                        explanation = back_data.explanation
-                        example = back_data.example
+                    if hasattr(card_data, "dict"):
+                        payload = card_data.dict()
+                    elif isinstance(card_data, dict):
+                        payload = card_data
                     else:
-                        answer = back_data.get("answer", "")
-                        explanation = back_data.get("explanation", "")
-                        example = back_data.get("example", "")
-
-                    if not question or not answer:
-                        logger.warning(f"Skipping card {i}: missing question or answer")
+                        logger.warning(
+                            f"Skipping card {i}: unsupported payload type {type(card_data)}"
+                        )
                         continue
 
-                    # Create Card object
-                    card = Card(
-                        card_type=card_type,
-                        front=CardFront(question=question),
-                        back=CardBack(
-                            answer=answer,
-                            explanation=explanation,
-                            example=example,
-                        ),
-                        metadata=metadata
-                        if isinstance(metadata, dict)
-                        else metadata.dict()
-                        if hasattr(metadata, "dict")
-                        else {},
-                    )
-
-                    # Ensure metadata includes subject and topic
-                    if card.metadata is not None:
-                        if "subject" not in card.metadata:
-                            card.metadata["subject"] = self.subject
-                        if "topic" not in card.metadata:
-                            card.metadata["topic"] = topic
-
+                    card = card_dict_to_card(payload, topic, self.subject)
                     cards.append(card)
 
                 except Exception as e:
@@ -234,357 +302,85 @@ Return your response as a JSON object with this structure:
             raise
 
 
-class PedagogicalAgent(BaseAgentWrapper):
-    """Pedagogical specialist for educational effectiveness"""
-
-    def __init__(self, openai_client: AsyncOpenAI):
-        config_manager = get_config_manager()
-        base_config = config_manager.get_agent_config("pedagogical")
-
-        if not base_config:
-            raise ValueError(
-                "pedagogical configuration not found - agent system not properly initialized"
-            )
-
-        super().__init__(base_config, openai_client)
-
-    async def review_cards(self, cards: List[Card]) -> List[Dict[str, Any]]:
-        """Review cards for pedagogical effectiveness"""
-        datetime.now()
-
-        try:
-            reviews = []
-
-            for i, card in enumerate(cards):
-                user_input = self._build_review_prompt(card, i)
-                response, usage = await self.execute(user_input)
-
-                try:
-                    review_data = (
-                        json.loads(response) if isinstance(response, str) else response
-                    )
-                    reviews.append(review_data)
-                except Exception as e:
-                    logger.warning(f"Failed to parse review for card {i}: {e}")
-                    reviews.append(
-                        {
-                            "approved": True,
-                            "feedback": f"Review parsing failed: {e}",
-                            "improvements": [],
-                        }
-                    )
-
-            # Record successful execution
-
-            return reviews
-
-        except Exception as e:
-            logger.error(f"PedagogicalAgent review failed: {e}")
-            raise
-
-    def _parse_review_response(self, response) -> Dict[str, Any]:
-        """Parse the review response into a dictionary"""
-        try:
-            if isinstance(response, str):
-                data = json.loads(response)
-            else:
-                data = response
-
-            # Validate required fields
-            required_fields = [
-                "pedagogical_quality",
-                "clarity",
-                "learning_effectiveness",
-            ]
-            if not all(field in data for field in required_fields):
-                raise ValueError("Missing required review fields")
-
-            return data
-
-        except json.JSONDecodeError as e:
-            logger.error(f"Failed to parse review response as JSON: {e}")
-            raise ValueError(f"Invalid review response: {e}")
-        except Exception as e:
-            logger.error(f"Failed to parse review response: {e}")
-            raise ValueError(f"Invalid review response: {e}")
-
-    def _build_review_prompt(self, card: Card, index: int) -> str:
-        """Build the review prompt for a single card"""
-        return f"""Review this flashcard for pedagogical effectiveness:
-
-Card {index + 1}:
-Question: {card.front.question}
-Answer: {card.back.answer}
-Explanation: {card.back.explanation}
-Example: {card.back.example}
-Metadata: {json.dumps(card.metadata, indent=2)}
-
-Evaluate the card based on:
-1. Learning Objectives: Does it have clear, measurable learning goals?
-2. Bloom's Taxonomy: What cognitive level does it target? Is it appropriate?
-3. Cognitive Load: Is the information manageable for learners?
-4. Difficulty Progression: Is the difficulty appropriate for the target level?
-5. Educational Value: Does it promote deep learning vs. memorization?
-
-Return your assessment as JSON:
-{{
-    "approved": true/false,
-    "cognitive_level": "remember|understand|apply|analyze|evaluate|create",
-    "difficulty_rating": 1-5,
-    "cognitive_load": "low|medium|high",
-    "educational_value": 1-5,
-    "feedback": "Detailed pedagogical assessment",
-    "improvements": ["specific improvement suggestion 1", "suggestion 2"],
-    "learning_objectives": ["clear learning objective 1", "objective 2"]
-}}"""
-
-
-class ContentStructuringAgent(BaseAgentWrapper):
-    """Content organization and formatting specialist"""
-
-    def __init__(self, openai_client: AsyncOpenAI):
-        config_manager = get_config_manager()
-        base_config = config_manager.get_agent_config("content_structuring")
-
-        if not base_config:
-            raise ValueError(
-                "content_structuring configuration not found - agent system not properly initialized"
-            )
-
-        super().__init__(base_config, openai_client)
-
-    async def structure_cards(self, cards: List[Card]) -> List[Card]:
-        """Structure and format cards for consistency"""
-        datetime.now()
+class QualityReviewAgent(BaseAgentWrapper):
+    """Single-pass quality review agent for lightweight validation and fixes."""
+
+    def __init__(self, openai_client: AsyncOpenAI, model: str):
+        config = AgentConfig(
+            name="quality_reviewer",
+            instructions=(
+                "You are a meticulous flashcard reviewer. Review each card for factual accuracy, clarity,"
+                " atomic scope, and answer quality. When needed, revise the card while keeping it concise and"
+                " faithful to the original intent. Always respond with a JSON object containing:"
+                ' {"approved": bool, "reason": string, "revised_card": object or null}.'
+                " The revised card must follow the input schema with fields card_type, front.question,"
+                " back.answer/explanation/example, and metadata."
+            ),
+            model=model,
+            temperature=0.2,
+            timeout=45.0,
+            retry_attempts=2,
+            enable_tracing=False,
+        )
+        super().__init__(config, openai_client)
+
+    async def review_card(self, card: Card) -> Tuple[Optional[Card], bool, str]:
+        """Review a card and optionally return a revised version."""
+
+        card_payload = {
+            "card_type": card.card_type,
+            "front": {"question": card.front.question if card.front else ""},
+            "back": {
+                "answer": card.back.answer if card.back else "",
+                "explanation": card.back.explanation if card.back else "",
+                "example": card.back.example if card.back else "",
+            },
+            "metadata": card.metadata or {},
+        }
+
+        user_input = (
+            "Review the following flashcard. Approve it if it is accurate, clear, and atomic."
+            " If improvements are needed, provide a revised_card with the corrections applied.\n\n"
+            "Flashcard JSON:\n"
+            f"{json.dumps(card_payload, ensure_ascii=False)}\n\n"
+            "Respond with JSON matching this schema:\n"
+            '{\n  "approved": true | false,\n  "reason": "short explanation",\n'
+            '  "revised_card": { ... } | null\n}'
+        )
 
         try:
-            structured_cards = []
-
-            for i, card in enumerate(cards):
-                user_input = self._build_structuring_prompt(card, i)
-                response, usage = await self.execute(user_input)
-
-                try:
-                    structured_data = (
-                        json.loads(response) if isinstance(response, str) else response
-                    )
-                    structured_card = self._parse_structured_card(structured_data, card)
-                    structured_cards.append(structured_card)
-                except Exception as e:
-                    logger.warning(f"Failed to structure card {i}: {e}")
-                    structured_cards.append(card)  # Keep original on failure
-
-            return structured_cards
-
+            response, _ = await self.execute(user_input)
         except Exception as e:
-            logger.error(f"ContentStructuringAgent failed: {e}")
-            raise
-
-    def _build_structuring_prompt(self, card: Card, index: int) -> str:
-        """Build the structuring prompt for a single card"""
-        return f"""Structure and format this flashcard for optimal learning:
-
-Original Card {index + 1}:
-Question: {card.front.question}
-Answer: {card.back.answer}
-Explanation: {card.back.explanation}
-Example: {card.back.example}
-Type: {card.card_type}
-Metadata: {json.dumps(card.metadata, indent=2)}
-
-Improve the card's structure and formatting:
-1. Ensure clear, concise, unambiguous question
-2. Provide complete, well-structured answer
-3. Add comprehensive explanation with reasoning
-4. Include relevant, practical example
-5. Enhance metadata with appropriate tags and categorization
-6. Maintain consistent formatting and style
-
-Return the improved card as JSON:
-{{
-    "card_type": "basic|cloze",
-    "front": {{
-        "question": "Improved, clear question"
-    }},
-    "back": {{
-        "answer": "Complete, well-structured answer",
-        "explanation": "Comprehensive explanation with reasoning",
-        "example": "Relevant, practical example"
-    }},
-    "metadata": {{
-        "topic": "specific topic",
-        "subject": "subject area",
-        "difficulty": "beginner|intermediate|advanced",
-        "tags": ["tag1", "tag2", "tag3"],
-        "learning_outcomes": ["outcome1", "outcome2"],
-        "prerequisites": ["prereq1", "prereq2"],
-        "estimated_time": "time in minutes",
-        "category": "category name"
-    }}
-}}"""
-
-    def _parse_structured_card(
-        self, structured_data: Dict[str, Any], original_card: Card
-    ) -> Card:
-        """Parse structured card data into Card object"""
-        try:
-            return Card(
-                card_type=structured_data.get("card_type", original_card.card_type),
-                front=CardFront(question=structured_data["front"]["question"]),
-                back=CardBack(
-                    answer=structured_data["back"]["answer"],
-                    explanation=structured_data["back"].get("explanation", ""),
-                    example=structured_data["back"].get("example", ""),
-                ),
-                metadata=structured_data.get("metadata", original_card.metadata),
-            )
-        except Exception as e:
-            logger.warning(f"Failed to parse structured card: {e}")
-            return original_card
-
-
-class GenerationCoordinator(BaseAgentWrapper):
-    """Coordinates the multi-agent card generation workflow"""
-
-    def __init__(self, openai_client: AsyncOpenAI):
-        config_manager = get_config_manager()
-        base_config = config_manager.get_agent_config("generation_coordinator")
-
-        if not base_config:
-            raise ValueError(
-                "generation_coordinator configuration not found - agent system not properly initialized"
-            )
-
-        super().__init__(base_config, openai_client)
-
-        # Initialize specialized agents
-        self.subject_expert = None
-        self.pedagogical = PedagogicalAgent(openai_client)
-        self.content_structuring = ContentStructuringAgent(openai_client)
-
-    async def coordinate_generation(
-        self,
-        topic: str,
-        subject: str = "general",
-        num_cards: int = 5,
-        difficulty: str = "intermediate",
-        enable_review: bool = True,
-        enable_structuring: bool = True,
-        context: Dict[str, Any] = None,
-    ) -> List[Card]:
-        """Coordinate the full card generation pipeline"""
-        datetime.now()
+            logger.error(f"Quality review failed to execute: {e}")
+            return card, True, "Review failed; keeping original card"
 
         try:
-            # Initialize subject expert for the specific subject
-            if not self.subject_expert or self.subject_expert.subject != subject:
-                self.subject_expert = SubjectExpertAgent(self.openai_client, subject)
-
-            logger.info(f"Starting coordinated generation: {topic} ({subject})")
-
-            # Step 1: Generate initial cards
-            cards = await self.subject_expert.generate_cards(
-                topic=topic, num_cards=num_cards, context=context
-            )
-
-            # Step 2: Pedagogical review (optional)
-            if enable_review and cards:
-                logger.info("Performing pedagogical review...")
-                reviews = await self.pedagogical.review_cards(cards)
-
-                # Filter or flag cards based on reviews
-                approved_cards = []
-                for card, review in zip(cards, reviews):
-                    if review.get("approved", True):
-                        approved_cards.append(card)
-                    else:
-                        logger.info(
-                            f"Card flagged for revision: {card.front.question[:50]}..."
-                        )
-
-                cards = approved_cards
-
-            # Step 3: Content structuring (optional)
-            if enable_structuring and cards:
-                logger.info("Performing content structuring...")
-                cards = await self.content_structuring.structure_cards(cards)
-
-            # Record successful coordination
-
-            logger.info(f"Generation coordination complete: {len(cards)} cards")
-            return cards
-
+            parsed = json.loads(response) if isinstance(response, str) else response
         except Exception as e:
-            logger.error(f"Generation coordination failed: {e}")
-            raise
-
-    async def generate_structured_cards(
-        self,
-        topic: str,
-        num_cards: int = 5,
-        difficulty: str = "intermediate",
-        context: Optional[Dict[str, Any]] = None,
-    ) -> List[Card]:
-        """Generate structured flashcards with enhanced metadata"""
-        try:
-            user_input = f"""Generate {num_cards} structured flashcards for: {topic}
-
-Difficulty: {difficulty}
-Requirements:
-- Include detailed metadata
-- Add learning outcomes
-- Specify prerequisites
-- Include related concepts
-- Estimate study time"""
-
-            response, usage = await self.execute(user_input)
-
-            # Log usage information
-            if usage and usage.get("total_tokens", 0) > 0:
-                logger.info(
-                    f"💰 Token Usage: {usage['total_tokens']} tokens (Input: {usage['input_tokens']}, Output: {usage['output_tokens']})"
+            logger.warning(f"Failed to parse review response as JSON: {e}")
+            return card, True, "Reviewer returned invalid JSON; keeping original"
+
+        approved = bool(parsed.get("approved", True))
+        reason = str(parsed.get("reason", ""))
+        revised_payload = parsed.get("revised_card")
+
+        revised_card: Optional[Card] = None
+        if isinstance(revised_payload, dict):
+            try:
+                metadata = revised_payload.get("metadata", {}) or {}
+                revised_subject = metadata.get("subject") or (card.metadata or {}).get(
+                    "subject",
+                    "general",
                 )
-
-            # Parse the structured response directly since it should be a CardsGenerationSchema
-            if hasattr(response, "cards") and response.cards:
-                return response.cards
-            else:
-                logger.warning("No cards found in structured response")
-                return []
-
-        except Exception as e:
-            logger.error(f"Structured card generation failed: {e}")
-            raise
-
-    async def generate_adaptive_cards(
-        self,
-        topic: str,
-        learning_style: str = "visual",
-        num_cards: int = 5,
-        context: Optional[Dict[str, Any]] = None,
-    ) -> List[Card]:
-        """Generate cards adapted to specific learning styles"""
-        try:
-            user_input = f"""Generate {num_cards} flashcards for: {topic}
-
-Learning Style: {learning_style}
-Adapt the content format and presentation to match this learning style."""
-
-            response, usage = await self.execute(user_input)
-
-            # Log usage information
-            if usage and usage.get("total_tokens", 0) > 0:
-                logger.info(
-                    f"💰 Token Usage: {usage['total_tokens']} tokens (Input: {usage['input_tokens']}, Output: {usage['output_tokens']})"
+                revised_topic = metadata.get("topic") or (card.metadata or {}).get(
+                    "topic",
+                    "General Concepts",
                 )
+                revised_card = card_dict_to_card(
+                    revised_payload, revised_topic, revised_subject
+                )
+            except Exception as e:
+                logger.warning(f"Failed to build revised card from review payload: {e}")
+                revised_card = None
 
-            # Parse the adaptive response directly since it should be a CardsGenerationSchema
-            if hasattr(response, "cards") and response.cards:
-                return response.cards
-            else:
-                logger.warning("No cards found in adaptive response")
-                return []
-
-        except Exception as e:
-            logger.error(f"Adaptive card generation failed: {e}")
-            raise
+        return revised_card or card, approved, reason or ""

ankigen_core/agents/integration.py

@@ -1,16 +1,16 @@
 # Main integration module for AnkiGen agent system
 
-from typing import List, Dict, Any, Tuple
+from typing import List, Dict, Any, Tuple, Optional
 from datetime import datetime
 
 
 from ankigen_core.logging import logger
 from ankigen_core.models import Card
 from ankigen_core.llm_interface import OpenAIClientManager
+from ankigen_core.context7 import Context7Client
 
-from .generators import GenerationCoordinator, SubjectExpertAgent
-from .judges import JudgeCoordinator
-from .enhancers import RevisionAgent, EnhancementAgent
+from .generators import SubjectExpertAgent, QualityReviewAgent
+from ankigen_core.agents.config import get_config_manager
 
 
 class AgentOrchestrator:
@@ -20,14 +20,8 @@ class AgentOrchestrator:
         self.client_manager = client_manager
         self.openai_client = None
 
-        # Initialize coordinators
-        self.generation_coordinator = None
-        self.judge_coordinator = None
-        self.revision_agent = None
-        self.enhancement_agent = None
-
-        # All agents enabled by default
-        self.all_agents_enabled = True
+        self.subject_expert = None
+        self.quality_reviewer = None
 
     async def initialize(self, api_key: str, model_overrides: Dict[str, str] = None):
         """Initialize the agent system"""
@@ -44,13 +38,7 @@ class AgentOrchestrator:
                 config_manager.update_models(model_overrides)
                 logger.info(f"Applied model overrides: {model_overrides}")
 
-            # Initialize all agents
-            self.generation_coordinator = GenerationCoordinator(self.openai_client)
-            self.judge_coordinator = JudgeCoordinator(self.openai_client)
-            self.revision_agent = RevisionAgent(self.openai_client)
-            self.enhancement_agent = EnhancementAgent(self.openai_client)
-
-            logger.info("Agent system initialized successfully")
+            logger.info("Agent system initialized successfully (simplified pipeline)")
 
         except Exception as e:
             logger.error(f"Failed to initialize agent system: {e}")
@@ -64,45 +52,66 @@ class AgentOrchestrator:
         difficulty: str = "intermediate",
         enable_quality_pipeline: bool = True,
         context: Dict[str, Any] = None,
+        library_name: Optional[str] = None,
+        library_topic: Optional[str] = None,
     ) -> Tuple[List[Card], Dict[str, Any]]:
         """Generate cards using the agent system"""
         start_time = datetime.now()
 
         try:
-            # Agents are always enabled now
-
             if not self.openai_client:
                 raise ValueError("Agent system not initialized")
 
             logger.info(f"Starting agent-based card generation: {topic} ({subject})")
 
-            # Phase 1: Generation
+            # Enhance context with library documentation if requested
+            enhanced_context = context or {}
+            library_docs = None
+
+            if library_name:
+                logger.info(f"Fetching library documentation for: {library_name}")
+                try:
+                    context7_client = Context7Client()
+                    library_docs = await context7_client.fetch_library_documentation(
+                        library_name, topic=library_topic, tokens=5000
+                    )
+
+                    if library_docs:
+                        enhanced_context["library_documentation"] = library_docs
+                        enhanced_context["library_name"] = library_name
+                        logger.info(
+                            f"Added {len(library_docs)} chars of {library_name} documentation to context"
+                        )
+                    else:
+                        logger.warning(
+                            f"Could not fetch documentation for library: {library_name}"
+                        )
+                except Exception as e:
+                    logger.error(f"Error fetching library documentation: {e}")
+
             cards = await self._generation_phase(
                 topic=topic,
                 subject=subject,
                 num_cards=num_cards,
                 difficulty=difficulty,
-                context=context,
+                context=enhanced_context,
             )
 
-            # Phase 2: Quality Assessment
-            quality_results = {}
-            if enable_quality_pipeline and self.judge_coordinator:
-                cards, quality_results = await self._quality_phase(cards)
-
-            # Phase 3: Enhancement
-            if self.enhancement_agent:
-                cards = await self._enhancement_phase(cards)
+            review_results = {}
+            if enable_quality_pipeline:
+                cards, review_results = await self._quality_review_phase(cards)
 
             # Collect metadata
             metadata = {
                 "generation_method": "agent_system",
                 "generation_time": (datetime.now() - start_time).total_seconds(),
                 "cards_generated": len(cards),
-                "quality_results": quality_results,
+                "review_results": review_results,
                 "topic": topic,
                 "subject": subject,
                 "difficulty": difficulty,
+                "library_name": library_name if library_name else None,
+                "library_docs_used": bool(library_docs),
             }
 
             logger.info(
@@ -124,116 +133,72 @@ class AgentOrchestrator:
     ) -> List[Card]:
         """Execute the card generation phase"""
 
-        if self.generation_coordinator:
-            # Use coordinated multi-agent generation
-            cards = await self.generation_coordinator.coordinate_generation(
-                topic=topic,
-                subject=subject,
-                num_cards=num_cards,
-                difficulty=difficulty,
-                enable_review=True,
-                enable_structuring=True,
-                context=context,
-            )
-        else:
-            # Use subject expert agent directly
-            subject_expert = SubjectExpertAgent(self.openai_client, subject)
-            cards = await subject_expert.generate_cards(
-                topic=topic, num_cards=num_cards, difficulty=difficulty, context=context
-            )
+        if not self.subject_expert or self.subject_expert.subject != subject:
+            self.subject_expert = SubjectExpertAgent(self.openai_client, subject)
+
+        # Add difficulty to context if needed
+        if context is None:
+            context = {}
+        context["difficulty"] = difficulty
+
+        cards = await self.subject_expert.generate_cards(
+            topic=topic, num_cards=num_cards, context=context
+        )
 
         logger.info(f"Generation phase complete: {len(cards)} cards generated")
         return cards
 
-    async def _quality_phase(
+    async def _quality_review_phase(
         self, cards: List[Card]
     ) -> Tuple[List[Card], Dict[str, Any]]:
-        """Execute the quality assessment and improvement phase"""
+        """Perform a single quality-review pass with optional fixes."""
 
-        if not self.judge_coordinator:
-            return cards, {"message": "Judge coordinator not available"}
+        if not cards:
+            return cards, {"message": "No cards to review"}
 
-        logger.info(f"Starting quality assessment for {len(cards)} cards")
+        logger.info(f"Performing quality review for {len(cards)} cards")
 
-        # Judge all cards
-        judge_results = await self.judge_coordinator.coordinate_judgment(
-            cards=cards,
-            enable_parallel=True,
-            min_consensus=0.6,
-        )
+        if not self.quality_reviewer:
+            # Use the same model as the subject expert by default.
+            subject_config = get_config_manager().get_agent_config("subject_expert")
+            reviewer_model = subject_config.model if subject_config else "gpt-4.1"
+            self.quality_reviewer = QualityReviewAgent(
+                self.openai_client, reviewer_model
+            )
 
-        # Separate approved and rejected cards
-        approved_cards = []
-        rejected_cards = []
+        reviewed_cards: List[Card] = []
+        approvals: List[Dict[str, Any]] = []
 
-        for card, decisions, approved in judge_results:
+        for card in cards:
+            reviewed_card, approved, reason = await self.quality_reviewer.review_card(
+                card
+            )
             if approved:
-                approved_cards.append(card)
+                reviewed_cards.append(reviewed_card)
             else:
-                rejected_cards.append((card, decisions))
-
-        # Attempt to revise rejected cards
-        revised_cards = []
-        if self.revision_agent and rejected_cards:
-            logger.info(f"Attempting to revise {len(rejected_cards)} rejected cards")
-
-            for card, decisions in rejected_cards:
-                try:
-                    revised_card = await self.revision_agent.revise_card(
-                        card=card,
-                        judge_decisions=decisions,
-                        max_iterations=2,
-                    )
-
-                    # Re-judge the revised card
-                    revision_results = await self.judge_coordinator.coordinate_judgment(
-                        cards=[revised_card],
-                        enable_parallel=False,  # Single card, no need for parallel
-                        min_consensus=0.6,
-                    )
-
-                    if revision_results and revision_results[0][2]:  # If approved
-                        revised_cards.append(revised_card)
-                    else:
-                        logger.warning(
-                            f"Revised card still rejected: {card.front.question[:50]}..."
-                        )
-
-                except Exception as e:
-                    logger.error(f"Failed to revise card: {e}")
-
-        # Combine approved and successfully revised cards
-        final_cards = approved_cards + revised_cards
-
-        # Prepare quality results
-        quality_results = {
-            "total_cards_judged": len(cards),
-            "initially_approved": len(approved_cards),
-            "initially_rejected": len(rejected_cards),
-            "successfully_revised": len(revised_cards),
-            "final_approval_rate": len(final_cards) / len(cards) if cards else 0,
-            "judge_decisions": len(judge_results),
+                approvals.append(
+                    {
+                        "question": card.front.question if card.front else "",
+                        "reason": reason,
+                    }
+                )
+
+        review_results = {
+            "total_cards_reviewed": len(cards),
+            "approved_cards": len(reviewed_cards),
+            "rejected_cards": approvals,
         }
 
-        logger.info(
-            f"Quality phase complete: {len(final_cards)}/{len(cards)} cards approved"
-        )
-        return final_cards, quality_results
-
-    async def _enhancement_phase(self, cards: List[Card]) -> List[Card]:
-        """Execute the enhancement phase"""
-
-        if not self.enhancement_agent:
-            return cards
-
-        logger.info(f"Starting enhancement for {len(cards)} cards")
-
-        enhanced_cards = await self.enhancement_agent.enhance_card_batch(
-            cards=cards, enhancement_targets=["explanation", "example", "metadata"]
-        )
+        if approvals:
+            logger.warning(
+                "Quality review rejected cards: %s",
+                "; ".join(
+                    f"{entry['question'][:50]}… ({entry['reason']})"
+                    for entry in approvals
+                ),
+            )
 
-        logger.info(f"Enhancement phase complete: {len(enhanced_cards)} cards enhanced")
-        return enhanced_cards
+        return reviewed_cards, review_results
 
     def get_performance_metrics(self) -> Dict[str, Any]:
         """Get performance metrics for the agent system"""

ankigen_core/agents/templates/generators.j2

@@ -5,33 +5,12 @@
         "instructions": "You are a world-class expert in {{ subject | default('the subject area') }} with deep pedagogical knowledge. \nYour role is to generate high-quality flashcards that demonstrate mastery of {{ subject | default('the subject') }} concepts.\n\nKey responsibilities:\n- Create ATOMIC cards: extremely short (1-9 words on back), break complex info into multiple simple cards\n- Use standardized, bland prompts without fancy formatting or unusual words\n- Design prompts that match real-life recall situations\n- Put ALL to-be-learned information on the BACK of cards, never in prompts\n- Ensure technical accuracy and depth appropriate for the target level\n- Use domain-specific terminology correctly\n- Connect concepts to prerequisite knowledge\n\nPrioritize atomic simplicity over comprehensive single cards. Generate cards that test understanding through simple, direct recall.",
         "model": "{{ subject_expert_model }}",
         "temperature": 0.7,
-        "timeout": 45.0,
+        "timeout": 120.0,
         "custom_prompts": {
             "math": "Focus on problem-solving strategies and mathematical reasoning",
             "science": "Emphasize experimental design and scientific method",
             "history": "Connect events to broader historical patterns and causation",
             "programming": "Include executable examples and best practices"
         }
-    },
-    "pedagogical": {
-        "name": "pedagogical",
-        "instructions": "You are an educational specialist focused on learning theory and instructional design.\nYour role is to ensure all flashcards follow educational best practices.\n\nApply these frameworks:\n- Bloom's Taxonomy: Ensure questions target appropriate cognitive levels\n- Spaced Repetition: Design cards for optimal retention\n- Cognitive Load Theory: Avoid overwhelming learners\n- Active Learning: Encourage engagement and application\n\nReview cards for:\n- Clear learning objectives\n- Appropriate difficulty progression\n- Effective use of examples and analogies\n- Prerequisite knowledge alignment",
-        "model": "{{ pedagogical_agent_model }}",
-        "temperature": 0.6,
-        "timeout": 30.0
-    },
-    "content_structuring": {
-        "name": "content_structuring",
-        "instructions": "You are a content organization specialist focused on atomic card design and optimal learning structure.\nYour role is to format and organize flashcard content following proven Anki principles.\n\nEnsure all cards follow atomic principles:\n- Break down any card longer than 9 words into multiple cards\n- Use standardized, bland prompt formats (no fancy words, formatting, or visual cues)\n- Consistent question structures (e.g., 'T [concept]' for terminology, '[concept] definition' for definitions)\n- Put ALL information to be learned on the BACK, never in prompts\n- Create 'handles' (>references) to connect related cards without making individual cards long\n- Use multiple difficulty levels for the same concept when appropriate\n\nPrioritize simplicity and consistency over comprehensive single cards.",
-        "model": "{{ content_structuring_model }}",
-        "temperature": 0.5,
-        "timeout": 25.0
-    },
-    "generation_coordinator": {
-        "name": "generation_coordinator",
-        "instructions": "You are the generation workflow coordinator. \nYour role is to orchestrate the card generation process and manage handoffs between specialized agents.\n\nResponsibilities:\n- Route requests to appropriate specialist agents\n- Coordinate parallel generation tasks\n- Manage workflow state and progress\n- Handle errors and fallback strategies\n- Optimize generation pipelines\n\nMake decisions based on content type, user preferences, and system load.",
-        "model": "{{ generation_coordinator_model }}",
-        "temperature": 0.3,
-        "timeout": 20.0
     }
 }

ankigen_core/card_generator.py

@@ -3,21 +3,16 @@
 import gradio as gr
 import pandas as pd
 from typing import List, Dict, Any
-import asyncio
-from urllib.parse import urlparse
 
 # Imports from our core modules
 from ankigen_core.utils import (
     get_logger,
     ResponseCache,
-    fetch_webpage_text,
     strip_html_tags,
 )
-from ankigen_core.llm_interface import OpenAIClientManager, structured_output_completion
+from ankigen_core.llm_interface import OpenAIClientManager
 from ankigen_core.models import (
     Card,
-    CardFront,
-    CardBack,
 )  # Import necessary Pydantic models
 
 # Import agent system - required
@@ -72,170 +67,7 @@ GENERATION_MODES = [
 # --- Core Functions --- (Moved and adapted from app.py)
 
 
-async def generate_cards_batch(
-    openai_client,  # Renamed from client to openai_client for clarity
-    cache: ResponseCache,  # Added cache parameter
-    model: str,
-    topic: str,
-    num_cards: int,
-    system_prompt: str,
-    generate_cloze: bool = False,
-    batch_size: int = 3,  # Keep batch_size, though not explicitly used in this version
-):
-    """Generate a batch of cards for a topic, potentially including cloze deletions"""
-
-    cloze_instruction = ""
-    if generate_cloze:
-        cloze_instruction = """
-        Where appropriate, generate Cloze deletion cards.
-        - For Cloze cards, set "card_type" to "cloze".
-        - Format the question field using Anki's cloze syntax (e.g., "The capital of France is {{c1::Paris}}.").
-        - The "answer" field should contain the full, non-cloze text or specific context for the cloze.
-        - For standard question/answer cards, set "card_type" to "basic".
-        """
-
-    cards_prompt = f"""
-    Generate {num_cards} ATOMIC flashcards for the topic: {topic}
-    
-    Follow these ATOMIC principles:
-    - Each answer should be 1-9 words maximum
-    - Use bland, standardized questions (no fancy formatting)
-    - Break complex concepts into multiple simple cards
-    - Put ALL learning content in answers, never in questions
-    - Use handles (>references) to connect related cards
-    - Design questions to match real-life recall situations
-    
-    {cloze_instruction}
-    Return your response as a JSON object with the following structure:
-    {{
-        "cards": [
-            {{
-                "card_type": "basic or cloze",
-                "front": {{
-                    "question": "question text (potentially with {{{{c1::cloze syntax}}}})"
-                }},
-                "back": {{
-                    "answer": "concise answer or full text for cloze",
-                    "explanation": "detailed explanation",
-                    "example": "practical example"
-                }},
-                "metadata": {{
-                    "prerequisites": ["list", "of", "prerequisites"],
-                    "learning_outcomes": ["list", "of", "outcomes"],
-                    "difficulty": "beginner/intermediate/advanced"
-                }}
-            }}
-            // ... more cards
-        ]
-    }}
-    """
-
-    try:
-        logger.info(
-            f"Generating card batch for {topic}, Cloze enabled: {generate_cloze}"
-        )
-        # Call the imported structured_output_completion, passing client and cache
-        response = await structured_output_completion(
-            openai_client=openai_client,
-            model=model,
-            response_format={"type": "json_object"},
-            system_prompt=system_prompt,
-            user_prompt=cards_prompt,
-            cache=cache,  # Pass the cache instance
-        )
-
-        if not response or "cards" not in response:
-            logger.error("Invalid cards response format")
-            raise ValueError("Failed to generate cards. Please try again.")
-
-        cards_list = []
-        for card_data in response["cards"]:
-            if "front" not in card_data or "back" not in card_data:
-                logger.warning(
-                    f"Skipping card due to missing front/back data: {card_data}"
-                )
-                continue
-            if "question" not in card_data["front"]:
-                logger.warning(f"Skipping card due to missing question: {card_data}")
-                continue
-            if (
-                "answer" not in card_data["back"]
-                or "explanation" not in card_data["back"]
-                or "example" not in card_data["back"]
-            ):
-                logger.warning(
-                    f"Skipping card due to missing answer/explanation/example: {card_data}"
-                )
-                continue
-
-            # Use imported Pydantic models
-            card = Card(
-                card_type=card_data.get("card_type", "basic"),
-                front=CardFront(
-                    question=strip_html_tags(card_data["front"].get("question", ""))
-                ),
-                back=CardBack(
-                    answer=strip_html_tags(card_data["back"].get("answer", "")),
-                    explanation=strip_html_tags(
-                        card_data["back"].get("explanation", "")
-                    ),
-                    example=strip_html_tags(card_data["back"].get("example", "")),
-                ),
-                metadata=card_data.get("metadata", {}),
-            )
-            cards_list.append(card)
-
-        return cards_list
-
-    except Exception as e:
-        logger.error(
-            f"Failed to generate cards batch for {topic}: {str(e)}", exc_info=True
-        )
-        raise  # Re-raise for the main function to handle
-
-
-async def judge_card(
-    openai_client,
-    cache: ResponseCache,
-    model: str,
-    card: Card,
-) -> bool:
-    """Use an LLM to validate a single card."""
-    system_prompt = (
-        "You review flashcards and decide if the question is clear and useful. "
-        'Respond with a JSON object like {"is_valid": true}.'
-    )
-    user_prompt = f"Question: {card.front.question}\nAnswer: {card.back.answer}"
-    try:
-        result = await structured_output_completion(
-            openai_client=openai_client,
-            model=model,
-            response_format={"type": "json_object"},
-            system_prompt=system_prompt,
-            user_prompt=user_prompt,
-            cache=cache,
-        )
-        if isinstance(result, dict):
-            return bool(result.get("is_valid", True))
-    except Exception as e:  # pragma: no cover - network or parse errors
-        logger.warning(f"LLM judge failed for card '{card.front.question}': {e}")
-    return True
-
-
-async def judge_cards(
-    openai_client,
-    cache: ResponseCache,
-    model: str,
-    cards: List[Card],
-) -> List[Card]:
-    """Filter cards using the LLM judge."""
-    validated: List[Card] = []
-    for card in cards:
-        if await judge_card(openai_client, cache, model, card):
-            validated.append(card)
-        else:
-            logger.info(f"Card rejected by judge: {card.front.question}")
-    return validated
+# Legacy functions removed - all card generation now handled by agent system
 
 
 async def orchestrate_card_generation(  # MODIFIED: Added async
@@ -253,6 +85,8 @@ async def orchestrate_card_generation(  # MODIFIED: Added async
     preference_prompt: str,
     generate_cloze: bool,
     use_llm_judge: bool = False,
+    library_name: str = None,
+    library_topic: str = None,
 ):
     """Orchestrates the card generation process based on UI inputs."""
 
@@ -265,34 +99,14 @@ async def orchestrate_card_generation(  # MODIFIED: Added async
     if AGENTS_AVAILABLE:
         logger.info("🤖 Using agent system for card generation")
         try:
-            # Initialize token tracker
             from ankigen_core.agents.token_tracker import get_token_tracker
 
             token_tracker = get_token_tracker()
 
-            # Initialize agent orchestrator with the actual model from UI
-            # Initialize orchestrator with model overrides
             orchestrator = AgentOrchestrator(client_manager)
 
-            # Set model overrides for all agents
-            logger.info(f"Overriding all agent models to use: {model_name}")
-            model_overrides = {
-                "generation_coordinator": model_name,
-                "subject_expert": model_name,
-                "pedagogical_agent": model_name,
-                "content_structuring": model_name,
-                "enhancement_agent": model_name,
-                "revision_agent": model_name,
-                "content_accuracy_judge": model_name,
-                "pedagogical_judge": model_name,
-                "clarity_judge": model_name,
-                "technical_judge": model_name,
-                "completeness_judge": model_name,
-                "judge_coordinator": model_name,
-            }
-
-            # Initialize with model overrides
-            await orchestrator.initialize(api_key_input, model_overrides)
+            logger.info(f"Using {model_name} for SubjectExpertAgent")
+            await orchestrator.initialize(api_key_input, {"subject_expert": model_name})
 
             # Map generation mode to subject
             agent_subject = "general"
@@ -303,22 +117,21 @@ async def orchestrate_card_generation(  # MODIFIED: Added async
             elif generation_mode == "text":
                 agent_subject = "content_analysis"
 
-            # Calculate total cards needed
             total_cards_needed = topic_number * cards_per_topic
 
-            # Prepare context for text mode
             context = {}
             if generation_mode == "text" and source_text:
                 context["source_text"] = source_text
 
-            # Generate cards with agents using the actual model from UI
             agent_cards, agent_metadata = await orchestrator.generate_cards_with_agents(
                 topic=subject if subject else "Mixed Topics",
                 subject=agent_subject,
                 num_cards=total_cards_needed,
-                difficulty="intermediate",  # Could be made configurable
+                difficulty="intermediate",
                 enable_quality_pipeline=True,
                 context=context,
+                library_name=library_name,
+                library_topic=library_topic,
             )
 
             # Get token usage from session
@@ -340,16 +153,14 @@ async def orchestrate_card_generation(  # MODIFIED: Added async
             if agent_cards:
                 formatted_cards = format_cards_for_dataframe(
                     agent_cards,
-                    topic_name=f"Agent Generated - {subject}"
-                    if subject
-                    else "Agent Generated",
+                    topic_name=subject if subject else "General",
                     start_index=1,
                 )
 
                 output_df = pd.DataFrame(
                     formatted_cards, columns=get_dataframe_columns()
                 )
-                total_cards_message = f"<div><b>🤖 Agent Generated Cards:</b> <span id='total-cards-count'>{len(output_df)}</span></div>"
+                total_cards_message = f"<div><b>Cards Generated:</b> <span id='total-cards-count'>{len(output_df)}</span></div>"
 
                 logger.info(
                     f"Agent system generated {len(output_df)} cards successfully"
@@ -373,539 +184,17 @@ async def orchestrate_card_generation(  # MODIFIED: Added async
                 "",
             )
 
-    # This should never be reached since agents are required
-    logger.error("Agent system not available but required")
-    if not api_key_input:
-        logger.warning("No API key provided to orchestrator")
-        gr.Error("OpenAI API key is required")
-        return pd.DataFrame(columns=get_dataframe_columns()), "API key is required.", 0
-    # Re-initialize client via manager if API key changes or not initialized
-    # This logic might need refinement depending on how API key state is managed in UI
-    try:
-        # Attempt to initialize (will raise error if key is invalid)
-        await client_manager.initialize_client(api_key_input)
-        openai_client = client_manager.get_client()
-    except (ValueError, RuntimeError, Exception) as e:
-        logger.error(f"Client initialization failed in orchestrator: {e}")
-        gr.Error(f"OpenAI Client Error: {e}")
-        return (
-            pd.DataFrame(columns=get_dataframe_columns()),
-            f"OpenAI Client Error: {e}",
-            0,
-        )
-
-    model = model_name
-    flattened_data = []
-    total_cards_generated = 0
-    # Use track_tqdm=True in the calling Gradio handler if desired
-    # progress_tracker = gr.Progress(track_tqdm=True)
-
-    # -------------------------------------
-
-    try:
-        # page_text_for_generation = "" # No longer needed here
-
-        # --- Web Mode (Crawler) is now handled by crawl_and_generate in ui_logic.py ---
-        # The 'web' case for orchestrate_card_generation is removed as it's a separate flow.
-        # This function now handles 'subject', 'path', and 'text' (where text can be a URL).
-
-        # --- Subject Mode ---
-        if generation_mode == "subject":
-            logger.info("Orchestrator: Subject Mode")
-            if not subject or not subject.strip():
-                gr.Error("Subject is required for 'Single Subject' mode.")
-                return (
-                    pd.DataFrame(columns=get_dataframe_columns()),
-                    "Subject is required.",
-                    gr.update(
-                        value="<div><b>Total Cards Generated:</b> <span id='total-cards-count'>0</span></div>",
-                        visible=False,
-                    ),
-                )
-            system_prompt = f"""You are an expert in {subject} and an experienced educator. {preference_prompt}"""
-            # Split subjects if multiple are comma-separated
-            individual_subjects = [s.strip() for s in subject.split(",") if s.strip()]
-            if (
-                not individual_subjects
-            ):  # Handle case where subject might be just commas or whitespace
-                gr.Error("Valid subject(s) required.")
-                return (
-                    pd.DataFrame(columns=get_dataframe_columns()),
-                    "Valid subject(s) required.",
-                    gr.update(
-                        value="<div><b>Total Cards Generated:</b> <span id='total-cards-count'>0</span></div>",
-                        visible=False,
-                    ),
-                )
-
-            topics_for_generation = []
-            # max(1, topic_number // len(individual_subjects))  # Distribute topic_number
-
-            for ind_subject in individual_subjects:
-                # For single/multiple subjects, we might generate sub-topics or just use the subject as a topic
-                # For simplicity, let's assume each subject passed is a "topic" for now,
-                # and cards_per_topic applies to each.
-                # Or, if topic_number > 1, we could try to make LLM break down ind_subject into num_topics_per_subject.
-                # Current UI has "Number of Topics" and "Cards per Topic".
-                # If "Number of Topics" is meant per subject provided, then this logic needs care.
-                # Let's assume "Number of Topics" is total, and we divide it.
-                # If "Single Subject" mode, topic_number might represent sub-topics of that single subject.
-
-                # For now, let's simplify: treat each provided subject as a high-level topic.
-                # And generate 'cards_per_topic' for each. 'topic_number' might be less relevant here or define sub-breakdown.
-                # To align with UI (topic_number and cards_per_topic), if multiple subjects,
-                # we could make `topic_number` apply to how many sub-topics to generate for EACH subject,
-                # and `cards_per_topic` for each of those sub-topics.
-                # Or, if len(individual_subjects) > 1, `topic_number` is ignored and we use `cards_per_topic` for each subject.
-
-                # Simpler: if 1 subject, topic_number is subtopics. If multiple, each is a topic.
-                if len(individual_subjects) == 1:
-                    # If it's a single subject, we might want to break it down into `topic_number` sub-topics.
-                    # This would require an LLM call to get sub-topics first.
-                    # For now, let's treat the single subject as one topic, and `topic_number` is ignored.
-                    # Or, let's assume `topic_number` means we want `topic_number` variations or aspects of this subject.
-                    # The prompt for generate_cards_batch takes a "topic".
-                    # Let's create `topic_number` "topics" that are just slight variations or aspects of the main subject.
-                    if topic_number == 1:
-                        topics_for_generation.append(
-                            {"name": ind_subject, "num_cards": cards_per_topic}
-                        )
-                    else:
-                        # This is a placeholder for a more sophisticated sub-topic generation
-                        # For now, just make `topic_number` distinct calls for the same subject if user wants more "topics"
-                        # gr.Info(f"Generating for {topic_number} aspects/sub-sections of '{ind_subject}'.")
-                        for i in range(topic_number):
-                            topics_for_generation.append(
-                                {
-                                    "name": f"{ind_subject} - Aspect {i + 1}",
-                                    "num_cards": cards_per_topic,
-                                }
-                            )
-                else:  # Multiple subjects provided
-                    topics_for_generation.append(
-                        {"name": ind_subject, "num_cards": cards_per_topic}
-                    )
-
-        # --- Learning Path Mode ---
-        elif generation_mode == "path":
-            logger.info("Orchestrator: Learning Path Mode")
-            # In path mode, 'subject' contains the pre-analyzed subjects, comma-separated.
-            # 'description' (the learning goal) was used by analyze_learning_path, not directly here for card gen.
-            if (
-                not subject or not subject.strip()
-            ):  # 'subject' here comes from the anki_cards_data_df after analysis
-                gr.Error("No subjects provided from learning path analysis.")
-                return (
-                    pd.DataFrame(columns=get_dataframe_columns()),
-                    "No subjects from path analysis.",
-                    gr.update(
-                        value="<div><b>Total Cards Generated:</b> <span id='total-cards-count'>0</span></div>",
-                        visible=False,
-                    ),
-                )
-
-            system_prompt = f"""You are an expert in curriculum design and an experienced educator. {preference_prompt}"""
-            analyzed_subjects = [s.strip() for s in subject.split(",") if s.strip()]
-            if not analyzed_subjects:
-                gr.Error("No valid subjects parsed from learning path.")
-                return (
-                    pd.DataFrame(columns=get_dataframe_columns()),
-                    "No valid subjects from path.",
-                    gr.update(
-                        value="<div><b>Total Cards Generated:</b> <span id='total-cards-count'>0</span></div>",
-                        visible=False,
-                    ),
-                )
-
-            # topic_number might be interpreted as how many cards to generate for EACH analyzed subject,
-            # or how many sub-topics to break each analyzed subject into.
-            # Given "Cards per Topic" slider, it's more likely each analyzed subject is a "topic".
-            topics_for_generation = [
-                {"name": subj, "num_cards": cards_per_topic}
-                for subj in analyzed_subjects
-            ]
-
-        # --- Text Mode / Single Web Page from Text Mode ---
-        elif generation_mode == "text":
-            logger.info("Orchestrator: Text Mode")
-            actual_text_to_process = source_text
-
-            if (
-                not actual_text_to_process or not actual_text_to_process.strip()
-            ):  # Check after potential fetch
-                gr.Error("Text input is empty.")
-                return (
-                    pd.DataFrame(columns=get_dataframe_columns()),
-                    "Text input is empty.",
-                    gr.update(
-                        value="<div><b>Total Cards Generated:</b> <span id='total-cards-count'>0</span></div>",
-                        visible=False,
-                    ),
-                )
-
-            # Check if source_text is a URL
-            # Use a more robust check for URL (e.g., regex or urllib.parse)
-            is_url = False
-            if isinstance(source_text, str) and source_text.strip().lower().startswith(
-                ("http://", "https://")
-            ):
-                try:
-                    # A more robust check could involve trying to parse it
-                    result = urlparse(source_text.strip())
-                    if all([result.scheme, result.netloc]):
-                        is_url = True
-                except ImportError:  # Fallback if urlparse not available (should be)
-                    pass  # is_url remains False
-
-            if is_url:
-                url_to_fetch = source_text.strip()
-                logger.info(f"Text mode identified URL: {url_to_fetch}")
-                gr.Info(f"🕸️ Fetching content from URL in text field: {url_to_fetch}...")
-                try:
-                    page_content = await asyncio.to_thread(
-                        fetch_webpage_text, url_to_fetch
-                    )  # Ensure fetch_webpage_text is thread-safe or run in executor
-                    if not page_content or not page_content.strip():
-                        gr.Warning(
-                            f"Could not extract meaningful text from URL: {url_to_fetch}. Please check the URL or page content."
-                        )
-                        return (
-                            pd.DataFrame(columns=get_dataframe_columns()),
-                            "No meaningful text extracted from URL.",
-                            gr.update(
-                                value="<div><b>Total Cards Generated:</b> <span id='total-cards-count'>0</span></div>",
-                                visible=False,
-                            ),
-                        )
-                    actual_text_to_process = page_content
-                    source_text_display_name = f"Content from {url_to_fetch}"
-                    gr.Info(
-                        f"✅ Successfully fetched text from URL (approx. {len(actual_text_to_process)} chars)."
-                    )
-                except Exception as e:
-                    logger.error(
-                        f"Failed to fetch or process URL {url_to_fetch} in text mode: {e}",
-                        exc_info=True,
-                    )
-                    gr.Error(f"Failed to fetch content from URL: {str(e)}")
-                    return (
-                        pd.DataFrame(columns=get_dataframe_columns()),
-                        f"URL fetch error: {str(e)}",
-                        gr.update(
-                            value="<div><b>Total Cards Generated:</b> <span id='total-cards-count'>0</span></div>",
-                            visible=False,
-                        ),
-                    )
-            else:  # Not a URL, or failed to parse as one
-                if (
-                    not source_text or not source_text.strip()
-                ):  # Re-check original source_text if not a URL
-                    gr.Error("Text input is empty.")
-                    return (
-                        pd.DataFrame(columns=get_dataframe_columns()),
-                        "Text input is empty.",
-                        gr.update(
-                            value="<div><b>Total Cards Generated:</b> <span id='total-cards-count'>0</span></div>",
-                            visible=False,
-                        ),
-                    )
-                actual_text_to_process = source_text  # Use as is
-                source_text_display_name = "Content from Provided Text"
-                logger.info("Text mode: Processing provided text directly.")
-
-            # For text mode (either direct text or fetched from URL), generate cards from this content.
-            # The LLM will need the text. We can pass it via the system prompt or a specialized user prompt.
-            # For now, let's use a system prompt that tells it to base cards on the provided text.
-            # And we'll create one "topic" for all cards.
-
-            system_prompt = f"""You are an expert in distilling information and creating flashcards from text. {preference_prompt}
-            Base your flashcards STRICTLY on the following text content provided by the user in their next message.
-            Do not use external knowledge unless explicitly asked to clarify something from the text.
-            The user will provide the text content that needs to be turned into flashcards."""  # System prompt now expects text in user prompt.
-
-            # The user_prompt in generate_cards_batch will need to include actual_text_to_process.
-            # Let's adapt generate_cards_batch or how it's called for this.
-            # For now, let's assume generate_cards_batch's `cards_prompt` will be wrapped or modified
-            # to include `actual_text_to_process` when `generation_mode` is "text".
-
-            # This requires a change in how `generate_cards_batch` constructs its `cards_prompt` if text is primary.
-            # Alternative: pass `actual_text_to_process` as part of the user_prompt to `structured_output_completion`
-            # directly from here, bypassing `generate_cards_batch`'s topic-based prompt for "text" mode.
-            # This seems cleaner.
-
-            # Let's make a direct call to structured_output_completion for "text" mode.
-            text_mode_user_prompt = f"""
-            Please generate {cards_per_topic * topic_number} ATOMIC flashcards based on the following text content.
-            
-            Follow these ATOMIC principles:
-            - Each answer should be 1-9 words maximum
-            - Use bland, standardized questions (no fancy formatting)
-            - Break complex concepts into multiple simple cards
-            - Put ALL learning content in answers, never in questions
-            - Use handles (>references) to connect related cards
-            - Design questions to match real-life recall situations
-            
-            Ensure the flashcards cover diverse aspects of the text.
-            {get_cloze_instruction(generate_cloze)}
-            Return your response as a JSON object with the following structure:
-            {get_card_json_structure_prompt()}
-
-            Text Content to process:
-            ---
-            {actual_text_to_process[:15000]}
-            ---
-            """  # Truncate to avoid excessive length, system prompt already set context.
-
-            gr.Info(f"Generating cards from: {source_text_display_name}...")
-            try:
-                response = await structured_output_completion(
-                    openai_client=openai_client,
-                    model=model,
-                    response_format={"type": "json_object"},
-                    system_prompt=system_prompt,  # System prompt instructs to use text from user prompt
-                    user_prompt=text_mode_user_prompt,  # User prompt contains the text
-                    cache=cache,
-                )
-                raw_cards = []  # Default if response is None
-                if response:
-                    raw_cards = response.get("cards", [])
-                else:
-                    logger.warning(
-                        "structured_output_completion returned None, defaulting to empty card list for text mode."
-                    )
-                processed_cards = process_raw_cards_data(raw_cards)
-                if use_llm_judge and processed_cards:
-                    processed_cards = await judge_cards(
-                        openai_client, cache, model, processed_cards
-                    )
-                formatted_cards = format_cards_for_dataframe(
-                    processed_cards, topic_name=source_text_display_name, start_index=1
-                )
-                flattened_data.extend(formatted_cards)
-                total_cards_generated += len(formatted_cards)
-
-                # Skip topics_for_generation loop for text mode as cards are generated directly.
-                topics_for_generation = []  # Ensure it's empty
-
-            except Exception as e:
-                logger.error(
-                    f"Error during 'From Text' card generation: {e}", exc_info=True
-                )
-                gr.Error(f"Error generating cards from text: {str(e)}")
-                return (
-                    pd.DataFrame(columns=get_dataframe_columns()),
-                    f"Text Gen Error: {str(e)}",
-                    gr.update(
-                        value="<div><b>Total Cards Generated:</b> <span id='total-cards-count'>0</span></div>",
-                        visible=False,
-                    ),
-                )
-
-        else:  # Should not happen if generation_mode is validated, but as a fallback
-            logger.error(f"Unknown generation mode: {generation_mode}")
-            gr.Error(f"Unknown generation mode: {generation_mode}")
-            return (
-                pd.DataFrame(columns=get_dataframe_columns()),
-                "Unknown mode.",
-                gr.update(
-                    value="<div><b>Total Cards Generated:</b> <span id='total-cards-count'>0</span></div>",
-                    visible=False,
-                ),
-            )
-
-        # --- Batch Generation Loop (for subject and path modes) ---
-        # progress_total_batches = len(topics_for_generation)
-        # current_batch_num = 0
-
-        for topic_info in (
-            topics_for_generation
-        ):  # This loop will be skipped if text_mode populated flattened_data directly
-            # current_batch_num += 1
-            # progress_tracker.progress(current_batch_num / progress_total_batches, desc=f"Generating for topic: {topic_info['name']}")
-            # logger.info(f"Progress: {current_batch_num}/{progress_total_batches} - Topic: {topic_info['name']}")
-            gr.Info(
-                f"Generating cards for topic: {topic_info['name']}..."
-            )  # UI feedback
-
-            try:
-                # System prompt is already set based on mode (subject/path)
-                # generate_cards_batch will use this system_prompt
-                batch_cards = await generate_cards_batch(
-                    openai_client,
-                    cache,
-                    model,
-                    topic_info["name"],
-                    topic_info["num_cards"],
-                    system_prompt,  # System prompt defined above based on mode
-                    generate_cloze,
-                )
-                if use_llm_judge and batch_cards:
-                    batch_cards = await judge_cards(
-                        openai_client, cache, model, batch_cards
-                    )
-                # Assign topic name to cards before formatting for DataFrame
-                formatted_batch = format_cards_for_dataframe(
-                    batch_cards,
-                    topic_name=topic_info["name"],
-                    start_index=total_cards_generated + 1,
-                )
-                flattened_data.extend(formatted_batch)
-                total_cards_generated += len(formatted_batch)
-                logger.info(
-                    f"Generated {len(formatted_batch)} cards for topic {topic_info['name']}"
-                )
-
-            except Exception as e:
-                logger.error(
-                    f"Error generating cards for topic {topic_info['name']}: {e}",
-                    exc_info=True,
-                )
-                # Optionally, decide if one topic failing should stop all, or just skip
-                gr.Warning(
-                    f"Could not generate cards for topic '{topic_info['name']}': {str(e)}. Skipping."
-                )
-                continue  # Continue to next topic
-
-        # --- Final Processing ---
-        if not flattened_data:
-            gr.Info(
-                "No cards were generated."
-            )  # More informative than just empty table
-            # Return empty dataframe with correct columns
-            return (
-                pd.DataFrame(columns=get_dataframe_columns()),
-                "No cards generated.",
-                gr.update(
-                    value="<div><b>Total Cards Generated:</b> <span id='total-cards-count'>0</span></div>",
-                    visible=False,
-                ),
-            )
-
-        # Deduplication (if needed, and if it makes sense across different topics)
-        # For now, deduplication logic might be too aggressive if topics are meant to have overlapping concepts from different angles.
-        # final_cards_data = deduplicate_cards(flattened_data) # Assuming deduplicate_cards expects list of dicts
-        final_cards_data = (
-            flattened_data  # Skipping deduplication for now to preserve topic structure
-        )
-
-        # Re-index cards if deduplication changed the count or if start_index logic wasn't perfect
-        # For now, format_cards_for_dataframe handles indexing.
-
-        output_df = pd.DataFrame(final_cards_data, columns=get_dataframe_columns())
-
-        total_cards_message = f"<div><b>💡 Legacy Generated Cards:</b> <span id='total-cards-count'>{len(output_df)}</span></div>"
-
-        logger.info(f"Legacy orchestration complete. Total cards: {len(output_df)}")
-        return output_df, total_cards_message
-
-    except Exception as e:
-        logger.error(
-            f"Critical error in orchestrate_card_generation: {e}", exc_info=True
-        )
-        gr.Error(f"An unexpected error occurred: {str(e)}")
-        return (
-            pd.DataFrame(columns=get_dataframe_columns()),
-            f"Unexpected error: {str(e)}",
-            gr.update(
-                value="<div><b>Total Cards Generated:</b> <span id='total-cards-count'>0</span></div>",
-                visible=False,
-            ),
-        )
-    finally:
-        # Placeholder if any cleanup is needed
-        pass
-
-
-# Helper function to get Cloze instruction string
-def get_cloze_instruction(generate_cloze: bool) -> str:
-    if generate_cloze:
-        return """
-        Where appropriate, generate Cloze deletion cards.
-        - For Cloze cards, set "card_type" to "cloze".
-        - Format the question field using Anki's cloze syntax (e.g., "The capital of France is {{c1::Paris}}.").
-        - The "answer" field should contain the full, non-cloze text or specific context for the cloze.
-        - For standard question/answer cards, set "card_type" to "basic".
-        """
-    return ""
-
-
-# Helper function to get JSON structure prompt for cards
-def get_card_json_structure_prompt() -> str:
-    return """
-    {
-        "cards": [
-            {
-                "card_type": "basic or cloze",
-                "front": {
-                    "question": "question text (potentially with {{{{c1::cloze syntax}}}})"
-                },
-                "back": {
-                    "answer": "concise answer or full text for cloze",
-                    "explanation": "detailed explanation",
-                    "example": "practical example"
-                },
-                "metadata": {
-                    "prerequisites": ["list", "of", "prerequisites"],
-                    "learning_outcomes": ["list", "of", "outcomes"],
-                    "difficulty": "beginner/intermediate/advanced"
-                }
-            }
-            // ... more cards
-        ]
-    }
-    """
-
-
-# Helper function to process raw card data from LLM into Card Pydantic models
-def process_raw_cards_data(cards_data: list) -> list[Card]:
-    cards_list = []
-    if not isinstance(cards_data, list):
-        logger.warning(
-            f"Expected a list of cards, got {type(cards_data)}. Raw data: {cards_data}"
-        )
-        return cards_list
+    # Agent system is required and should never fail to be available
+    logger.error("Agent system failed but is required - this should not happen")
+    gr.Error("Agent system is required but not available")
+    return (
+        pd.DataFrame(columns=get_dataframe_columns()),
+        "Agent system error",
+        "",
+    )
 
-    for card_item in cards_data:
-        if not isinstance(card_item, dict):
-            logger.warning(
-                f"Expected card item to be a dict, got {type(card_item)}. Item: {card_item}"
-            )
-            continue
-        try:
-            # Basic validation for essential fields
-            if (
-                not all(k in card_item for k in ["front", "back"])
-                or not isinstance(card_item["front"], dict)
-                or not isinstance(card_item["back"], dict)
-                or "question" not in card_item["front"]
-                or "answer" not in card_item["back"]
-            ):
-                logger.warning(
-                    f"Skipping card due to missing essential fields: {card_item}"
-                )
-                continue
 
-            card = Card(
-                card_type=card_item.get("card_type", "basic"),
-                front=CardFront(
-                    question=strip_html_tags(card_item["front"].get("question", ""))
-                ),
-                back=CardBack(
-                    answer=strip_html_tags(card_item["back"].get("answer", "")),
-                    explanation=strip_html_tags(
-                        card_item["back"].get("explanation", "")
-                    ),
-                    example=strip_html_tags(card_item["back"].get("example", "")),
-                ),
-                metadata=card_item.get("metadata", {}),
-            )
-            cards_list.append(card)
-        except Exception as e:  # Catch Pydantic validation errors or others
-            logger.error(
-                f"Error processing card data item: {card_item}. Error: {e}",
-                exc_info=True,
-            )
-    return cards_list
+# Legacy helper functions removed - all processing now handled by agent system
 
 
 # --- Formatting and Utility Functions --- (Moved and adapted)

ankigen_core/context7.py

@@ -0,0 +1,177 @@
+"""Context7 integration for library documentation"""
+
+import asyncio
+import subprocess
+import json
+from typing import Optional, Dict, Any
+from ankigen_core.logging import logger
+
+
+class Context7Client:
+    """Context7 MCP client for fetching library documentation"""
+
+    def __init__(self):
+        self.server_process = None
+
+    async def call_context7_tool(
+        self, tool_name: str, args: Dict[str, Any]
+    ) -> Optional[Dict[str, Any]]:
+        """Call a Context7 tool via direct JSONRPC"""
+        try:
+            # Build the JSONRPC request
+            request = {
+                "jsonrpc": "2.0",
+                "id": 1,
+                "method": "tools/call",
+                "params": {"name": tool_name, "arguments": args},
+            }
+
+            # Call the Context7 server
+            process = await asyncio.create_subprocess_exec(
+                "npx",
+                "@upstash/context7-mcp",
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+
+            # Send initialization first
+            init_request = {
+                "jsonrpc": "2.0",
+                "id": 0,
+                "method": "initialize",
+                "params": {
+                    "protocolVersion": "2025-06-18",
+                    "capabilities": {},
+                    "clientInfo": {"name": "ankigen", "version": "1.0.0"},
+                },
+            }
+
+            # Send both requests
+            input_data = json.dumps(init_request) + "\n" + json.dumps(request) + "\n"
+            stdout, stderr = await process.communicate(input=input_data.encode())
+
+            # Parse responses
+            responses = stdout.decode().strip().split("\n")
+            if len(responses) >= 2:
+                # Skip init response, get tool response
+                tool_response = json.loads(responses[1])
+
+                if "result" in tool_response:
+                    result = tool_response["result"]
+                    # Extract content from the result
+                    if "content" in result and result["content"]:
+                        content_item = result["content"][0]
+                        if "text" in content_item:
+                            return {"text": content_item["text"], "success": True}
+                        elif "type" in content_item and content_item["type"] == "text":
+                            return {
+                                "text": content_item.get("text", ""),
+                                "success": True,
+                            }
+                    return {"error": "No content in response", "success": False}
+                elif "error" in tool_response:
+                    return {"error": tool_response["error"], "success": False}
+
+            return {"error": "Invalid response format", "success": False}
+
+        except Exception as e:
+            logger.error(f"Error calling Context7 tool {tool_name}: {e}")
+            return {"error": str(e), "success": False}
+
+    async def resolve_library_id(self, library_name: str) -> Optional[str]:
+        """Resolve a library name to a Context7-compatible ID"""
+        logger.info(f"Resolving library ID for: {library_name}")
+
+        result = await self.call_context7_tool(
+            "resolve-library-id", {"libraryName": library_name}
+        )
+
+        if result and result.get("success") and result.get("text"):
+            # Parse the text to extract library ID
+            text = result["text"]
+            import re
+
+            # First, look for specific Context7-compatible library ID mentions
+            lines = text.split("\n")
+            for line in lines:
+                if "Context7-compatible library ID:" in line:
+                    # Extract the ID after the colon
+                    parts = line.split("Context7-compatible library ID:")
+                    if len(parts) > 1:
+                        library_id = parts[1].strip()
+                        if library_id.startswith("/"):
+                            logger.info(
+                                f"Resolved '{library_name}' to ID: {library_id}"
+                            )
+                            return library_id
+
+            # Fallback: Look for library ID pattern but be more specific
+            # Must have actual library names, not generic /org/project
+            matches = re.findall(r"/[\w-]+/[\w.-]+(?:/[\w.-]+)?", text)
+            for match in matches:
+                # Filter out generic placeholders
+                if match != "/org/project" and "example" not in match.lower():
+                    logger.info(f"Resolved '{library_name}' to ID: {match}")
+                    return match
+
+        logger.warning(f"Could not resolve library ID for '{library_name}'")
+        return None
+
+    async def get_library_docs(
+        self, library_id: str, topic: Optional[str] = None, tokens: int = 5000
+    ) -> Optional[str]:
+        """Get documentation for a library"""
+        logger.info(
+            f"Fetching docs for: {library_id}" + (f" (topic: {topic})" if topic else "")
+        )
+
+        args = {"context7CompatibleLibraryID": library_id, "tokens": tokens}
+        if topic:
+            args["topic"] = topic
+
+        result = await self.call_context7_tool("get-library-docs", args)
+
+        if result and result.get("success") and result.get("text"):
+            docs = result["text"]
+            logger.info(f"Retrieved {len(docs)} characters of documentation")
+            return docs
+
+        logger.warning(f"Could not fetch docs for '{library_id}'")
+        return None
+
+    async def fetch_library_documentation(
+        self, library_name: str, topic: Optional[str] = None, tokens: int = 5000
+    ) -> Optional[str]:
+        """Convenience method to resolve and fetch docs in one call"""
+        library_id = await self.resolve_library_id(library_name)
+        if not library_id:
+            return None
+
+        return await self.get_library_docs(library_id, topic, tokens)
+
+
+async def test_context7():
+    """Test the Context7 integration"""
+    client = Context7Client()
+
+    print("Testing Context7 integration...")
+
+    # Test resolving a library
+    library_id = await client.resolve_library_id("react")
+    if library_id:
+        print(f"✓ Resolved 'react' to ID: {library_id}")
+
+        # Test fetching docs
+        docs = await client.get_library_docs(library_id, topic="hooks", tokens=2000)
+        if docs:
+            print(f"✓ Fetched {len(docs)} characters of documentation")
+            print(f"Preview: {docs[:300]}...")
+        else:
+            print("✗ Failed to fetch documentation")
+    else:
+        print("✗ Failed to resolve library ID")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_context7())

ankigen_core/utils.py

@@ -9,7 +9,6 @@ from bs4 import BeautifulSoup
 from functools import lru_cache
 from typing import Any, Optional
 import time
-import re
 
 # --- Logging Setup ---
 _logger_instance = None
@@ -196,11 +195,12 @@ class RateLimiter:
 # def some_other_util_function():
 #     pass
 
-HTML_TAG_REGEX = re.compile(r"<[^>]*>")
-
 
 def strip_html_tags(text: str) -> str:
-    """Removes HTML tags from a string."""
+    """Removes HTML tags from a string using a safe, non-regex approach."""
     if not isinstance(text, str):
         return str(text)  # Ensure it's a string, or return as is if not coercible
-    return HTML_TAG_REGEX.sub("", text).strip()
+
+    # Use BeautifulSoup for safe HTML parsing
+    soup = BeautifulSoup(text, "html.parser")
+    return soup.get_text().strip()

app.py

@@ -256,6 +256,21 @@ def create_ankigen_interface():
                             info="Your key is used solely for processing your requests.",
                             elem_id="api-key-textbox",
                         )
+
+                        # Context7 Library Documentation
+                        with gr.Accordion(
+                            "Library Documentation (optional)", open=False
+                        ):
+                            library_name_input = gr.Textbox(
+                                label="Library Name",
+                                placeholder="e.g., 'react', 'tensorflow', 'pandas'",
+                                info="Fetch up-to-date documentation for this library",
+                            )
+                            library_topic_input = gr.Textbox(
+                                label="Documentation Focus (optional)",
+                                placeholder="e.g., 'hooks', 'data loading', 'transforms'",
+                                info="Specific topic within the library to focus on",
+                            )
                     with gr.Column(scale=1):
                         with gr.Accordion("Advanced Settings", open=False):
                             model_choices_ui = [
@@ -302,161 +317,9 @@ def create_ankigen_interface():
                                 label="Generate Cloze Cards (Experimental)",
                                 value=False,
                             )
-
-                            # Agent System Controls (simplified since we're agent-only)
-                            if AGENTS_AVAILABLE_APP:
-                                # Hidden dropdown for compatibility - always set to agent_only
-                                agent_mode_dropdown = gr.Dropdown(
-                                    choices=[("Agent Only", "agent_only")],
-                                    value="agent_only",
-                                    label="Agent Mode",
-                                    visible=False,
-                                )
-
-                                with gr.Accordion("Agent Configuration", open=False):
-                                    gr.Markdown("**Core Generation Pipeline**")
-                                    enable_subject_expert = gr.Checkbox(
-                                        label="Subject Expert Agent",
-                                        value=True,
-                                        info="Domain-specific expertise",
-                                    )
-                                    enable_generation_coordinator = gr.Checkbox(
-                                        label="Generation Coordinator",
-                                        value=True,
-                                        info="Orchestrates multi-agent generation",
-                                    )
-
-                                    gr.Markdown("**Quality Assurance**")
-                                    enable_content_judge = gr.Checkbox(
-                                        label="Content Accuracy Judge",
-                                        value=True,
-                                        info="Factual correctness validation",
-                                    )
-                                    enable_clarity_judge = gr.Checkbox(
-                                        label="Clarity Judge",
-                                        value=True,
-                                        info="Language clarity and comprehension",
-                                    )
-
-                                    gr.Markdown("**Optional Enhancements**")
-                                    enable_pedagogical_agent = gr.Checkbox(
-                                        label="Pedagogical Agent",
-                                        value=False,
-                                        info="Educational effectiveness review",
-                                    )
-                                    enable_pedagogical_judge = gr.Checkbox(
-                                        label="Pedagogical Judge",
-                                        value=False,
-                                        info="Learning theory compliance",
-                                    )
-                                    enable_enhancement_agent = gr.Checkbox(
-                                        label="Enhancement Agent",
-                                        value=False,
-                                        info="Content enrichment and metadata",
-                                    )
-
-                                    with gr.Accordion(
-                                        "🛠️ Agent Model Selection", open=False
-                                    ):
-                                        gr.Markdown("**Individual Agent Models**")
-
-                                        # Generator models
-                                        subject_expert_model = gr.Dropdown(
-                                            choices=model_choices_ui,
-                                            value="gpt-4.1",
-                                            label="Subject Expert Model",
-                                            info="Model for domain expertise",
-                                            allow_custom_value=True,
-                                        )
-                                        generation_coordinator_model = gr.Dropdown(
-                                            choices=model_choices_ui,
-                                            value="gpt-4.1-nano",
-                                            label="Generation Coordinator Model",
-                                            info="Model for orchestration",
-                                            allow_custom_value=True,
-                                        )
-
-                                        # Judge models
-                                        content_judge_model = gr.Dropdown(
-                                            choices=model_choices_ui,
-                                            value="gpt-4.1",
-                                            label="Content Accuracy Judge Model",
-                                            info="Model for fact-checking",
-                                            allow_custom_value=True,
-                                        )
-                                        clarity_judge_model = gr.Dropdown(
-                                            choices=model_choices_ui,
-                                            value="gpt-4.1-nano",
-                                            label="Clarity Judge Model",
-                                            info="Model for language clarity",
-                                            allow_custom_value=True,
-                                        )
-
-                                        # Enhancement models
-                                        pedagogical_agent_model = gr.Dropdown(
-                                            choices=model_choices_ui,
-                                            value="gpt-4.1",
-                                            label="Pedagogical Agent Model",
-                                            info="Model for educational theory",
-                                            allow_custom_value=True,
-                                        )
-                                        enhancement_agent_model = gr.Dropdown(
-                                            choices=model_choices_ui,
-                                            value="gpt-4.1",
-                                            label="Enhancement Agent Model",
-                                            info="Model for content enrichment",
-                                            allow_custom_value=True,
-                                        )
-                            else:
-                                # Placeholder when agents not available
-                                agent_mode_dropdown = gr.Dropdown(
-                                    choices=[("Legacy Only", "legacy")],
-                                    value="legacy",
-                                    label="Agent Mode",
-                                    info="Agent system not available",
-                                    interactive=False,
-                                )
-                                enable_subject_expert = gr.Checkbox(
-                                    value=False, visible=False
-                                )
-                                enable_generation_coordinator = gr.Checkbox(
-                                    value=False, visible=False
-                                )
-                                enable_pedagogical_agent = gr.Checkbox(
-                                    value=False, visible=False
-                                )
-                                enable_content_judge = gr.Checkbox(
-                                    value=False, visible=False
-                                )
-                                enable_clarity_judge = gr.Checkbox(
-                                    value=False, visible=False
-                                )
-                                enable_pedagogical_judge = gr.Checkbox(
-                                    value=False, visible=False
-                                )
-                                enable_enhancement_agent = gr.Checkbox(
-                                    value=False, visible=False
-                                )
-
-                                # Hidden model dropdowns for non-agent mode
-                                subject_expert_model = gr.Dropdown(
-                                    value="gpt-4.1", visible=False
-                                )
-                                generation_coordinator_model = gr.Dropdown(
-                                    value="gpt-4.1-nano", visible=False
-                                )
-                                content_judge_model = gr.Dropdown(
-                                    value="gpt-4.1", visible=False
-                                )
-                                clarity_judge_model = gr.Dropdown(
-                                    value="gpt-4.1-nano", visible=False
-                                )
-                                pedagogical_agent_model = gr.Dropdown(
-                                    value="gpt-4.1", visible=False
-                                )
-                                enhancement_agent_model = gr.Dropdown(
-                                    value="gpt-4.1", visible=False
-                                )
+                            gr.Markdown(
+                                "*Cards are generated by the subject expert agent with a quick self-review to catch obvious gaps.*"
+                            )
 
             generate_button = gr.Button("Generate Cards", variant="primary")
 
@@ -655,96 +518,10 @@ def create_ankigen_interface():
                 cards_per_topic_val,
                 preference_prompt_val,
                 generate_cloze_checkbox_val,
-                agent_mode_val,
-                enable_subject_expert_val,
-                enable_generation_coordinator_val,
-                enable_pedagogical_agent_val,
-                enable_content_judge_val,
-                enable_clarity_judge_val,
-                enable_pedagogical_judge_val,
-                enable_enhancement_agent_val,
-                subject_expert_model_val,
-                generation_coordinator_model_val,
-                content_judge_model_val,
-                clarity_judge_model_val,
-                pedagogical_agent_model_val,
-                enhancement_agent_model_val,
+                library_name_val,
+                library_topic_val,
                 progress=gr.Progress(track_tqdm=True),  # Added progress tracker
             ):
-                # Apply agent settings if agents are available
-                if AGENTS_AVAILABLE_APP:
-                    import os
-
-                    # Set agent mode
-                    os.environ["ANKIGEN_AGENT_MODE"] = agent_mode_val
-
-                    # Set individual agent flags (using correct environment variable names)
-                    os.environ["ANKIGEN_ENABLE_SUBJECT_EXPERT"] = str(
-                        enable_subject_expert_val
-                    ).lower()
-                    os.environ["ANKIGEN_ENABLE_GENERATION_COORDINATOR"] = str(
-                        enable_generation_coordinator_val
-                    ).lower()
-                    os.environ["ANKIGEN_ENABLE_PEDAGOGICAL_AGENT"] = str(
-                        enable_pedagogical_agent_val
-                    ).lower()
-                    os.environ["ANKIGEN_ENABLE_CONTENT_JUDGE"] = str(
-                        enable_content_judge_val
-                    ).lower()
-                    os.environ["ANKIGEN_ENABLE_CLARITY_JUDGE"] = str(
-                        enable_clarity_judge_val
-                    ).lower()
-                    os.environ["ANKIGEN_ENABLE_PEDAGOGICAL_JUDGE"] = str(
-                        enable_pedagogical_judge_val
-                    ).lower()
-                    os.environ["ANKIGEN_ENABLE_ENHANCEMENT_AGENT"] = str(
-                        enable_enhancement_agent_val
-                    ).lower()
-
-                    # Enable additional required flags for proper agent coordination
-                    os.environ["ANKIGEN_ENABLE_JUDGE_COORDINATOR"] = (
-                        "true"  # Required for judge coordination
-                    )
-                    os.environ["ANKIGEN_ENABLE_PARALLEL_JUDGING"] = (
-                        "true"  # Enable parallel judging for performance
-                    )
-
-                    # Configure agent models from UI selections
-                    model_overrides = {
-                        "subject_expert": subject_expert_model_val,
-                        "generation_coordinator": generation_coordinator_model_val,
-                        "content_accuracy_judge": content_judge_model_val,
-                        "clarity_judge": clarity_judge_model_val,
-                        "pedagogical_agent": pedagogical_agent_model_val,
-                        "enhancement_agent": enhancement_agent_model_val,
-                    }
-
-                    # Template variables for Jinja rendering
-                    template_vars = {
-                        "subject": subject_val or "general studies",
-                        "difficulty": "intermediate",  # Could be made configurable
-                        "topic": subject_val or "general concepts",
-                    }
-
-                    # Initialize config manager with model overrides and template variables
-                    from ankigen_core.agents.config import get_config_manager
-
-                    get_config_manager(model_overrides, template_vars)
-
-                    # Log the agent configuration
-                    logger.info(f"Agent mode set to: {agent_mode_val}")
-                    logger.info(f"Model overrides: {model_overrides}")
-                    logger.info(
-                        f"Active agents: Subject Expert={enable_subject_expert_val}, Generation Coordinator={enable_generation_coordinator_val}, Content Judge={enable_content_judge_val}, Clarity Judge={enable_clarity_judge_val}"
-                    )
-
-                    # Reload feature flags to pick up the new environment variables
-                    try:
-                        # Agent system is available
-                        logger.info("Agent system enabled")
-                    except Exception as e:
-                        logger.warning(f"Failed to reload feature flags: {e}")
-
                 # Recreate the partial function call, but now it can be awaited
                 # The actual orchestrate_card_generation is already partially applied with client_manager and response_cache
                 # So, we need to get that specific partial object if it's stored, or redefine the partial logic here.
@@ -762,6 +539,8 @@ def create_ankigen_interface():
                     cards_per_topic_val,
                     preference_prompt_val,
                     generate_cloze_checkbox_val,
+                    library_name=library_name_val if library_name_val else None,
+                    library_topic=library_topic_val if library_topic_val else None,
                 )
                 # Expect 3-tuple return (dataframe, total_cards_html, token_usage_html)
 
@@ -778,20 +557,8 @@ def create_ankigen_interface():
                     cards_per_topic,
                     preference_prompt,
                     generate_cloze_checkbox,
-                    agent_mode_dropdown,
-                    enable_subject_expert,
-                    enable_generation_coordinator,
-                    enable_pedagogical_agent,
-                    enable_content_judge,
-                    enable_clarity_judge,
-                    enable_pedagogical_judge,
-                    enable_enhancement_agent,
-                    subject_expert_model,
-                    generation_coordinator_model,
-                    content_judge_model,
-                    clarity_judge_model,
-                    pedagogical_agent_model,
-                    enhancement_agent_model,
+                    library_name_input,
+                    library_topic_input,
                 ],
                 outputs=[output, total_cards_html, token_usage_html],
                 show_progress="full",

pyproject.toml

@@ -12,26 +12,27 @@ authors = [
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "openai>=1.91.0",
-    "openai-agents>=0.1.0",
-    "gradio>=5.34.2",
+    "openai>=1.109.1",
+    "openai-agents>=0.3.2",
+    "gradio>=5.47.0",
     "tenacity>=9.1.2",
     "genanki>=0.13.1",
-    "pydantic==2.10.6",
-    "pandas==2.2.3",
-    "beautifulsoup4==4.12.3",
-    "lxml==5.2.2",
-    "tiktoken>=0.9.0",
+    "pydantic==2.11.9",
+    "pandas>=2.3.2",
+    "beautifulsoup4==4.13.5",
+    "lxml>=6.0.2",
+    "tiktoken>=0.11.0",
+    "fastmcp>=2.12.3",
 ]
 
 [project.optional-dependencies]
 dev = [
-    "pytest>=8.4.1",
-    "pytest-cov>=6.2.1",
-    "pytest-mock>=3.14.1",
-    "ruff>=0.12.0",
-    "black>=25.1.0",
-    "pre-commit>=4.2.0",
+    "pytest>=8.4.2",
+    "pytest-cov>=7.0.0",
+    "pytest-mock>=3.15.1",
+    "ruff>=0.13.1",
+    "black>=25.9.0",
+    "pre-commit>=4.3.0",
     "pytest-anyio>=0.0.0",
 ]
 

requirements.txt

@@ -1,249 +1,107 @@
-# This file was autogenerated by uv via the following command:
-#    uv pip compile pyproject.toml --python-version 3.10 -o requirements.txt
 aiofiles==24.1.0
-    # via gradio
 annotated-types==0.7.0
-    # via pydantic
 anyio==4.9.0
-    # via
-    #   gradio
-    #   httpx
-    #   mcp
-    #   openai
-    #   sse-starlette
-    #   starlette
 attrs==25.3.0
-    # via
-    #   jsonschema
-    #   referencing
-beautifulsoup4==4.12.3
-    # via ankigen (pyproject.toml)
+authlib==1.6.4
+beautifulsoup4==4.13.5
+brotli==1.1.0
 cached-property==2.0.1
-    # via genanki
 certifi==2025.6.15
-    # via
-    #   httpcore
-    #   httpx
-    #   requests
+cffi==2.0.0
 charset-normalizer==3.4.2
-    # via requests
 chevron==0.14.0
-    # via genanki
 click==8.2.1
-    # via
-    #   typer
-    #   uvicorn
 colorama==0.4.6
-    # via griffe
+cryptography==46.0.1
+cyclopts==3.24.0
 distro==1.9.0
-    # via openai
+dnspython==2.8.0
+docstring-parser==0.17.0
+docutils==0.22.2
+email-validator==2.3.0
 exceptiongroup==1.3.0
-    # via anyio
 fastapi==0.115.13
-    # via gradio
+fastmcp==2.12.3
 ffmpy==0.6.0
-    # via gradio
 filelock==3.18.0
-    # via huggingface-hub
 frozendict==2.4.6
-    # via genanki
 fsspec==2025.5.1
-    # via
-    #   gradio-client
-    #   huggingface-hub
 genanki==0.13.1
-    # via ankigen (pyproject.toml)
-gradio==5.34.2
-    # via ankigen (pyproject.toml)
-gradio-client==1.10.3
-    # via gradio
+gradio==5.47.0
+gradio-client==1.13.2
 griffe==1.7.3
-    # via openai-agents
 groovy==0.1.2
-    # via gradio
 h11==0.16.0
-    # via
-    #   httpcore
-    #   uvicorn
 hf-xet==1.1.5
-    # via huggingface-hub
 httpcore==1.0.9
-    # via httpx
 httpx==0.28.1
-    # via
-    #   gradio
-    #   gradio-client
-    #   mcp
-    #   openai
-    #   safehttpx
 httpx-sse==0.4.1
-    # via mcp
-huggingface-hub==0.33.1
-    # via
-    #   gradio
-    #   gradio-client
+huggingface-hub==0.35.1
 idna==3.10
-    # via
-    #   anyio
-    #   httpx
-    #   requests
+isodate==0.7.2
 jinja2==3.1.6
-    # via gradio
 jiter==0.10.0
-    # via openai
 jsonschema==4.24.0
-    # via mcp
+jsonschema-path==0.3.4
 jsonschema-specifications==2025.4.1
-    # via jsonschema
-lxml==5.2.2
-    # via ankigen (pyproject.toml)
+lazy-object-proxy==1.12.0
+lxml==6.0.2
 markdown-it-py==3.0.0
-    # via rich
 markupsafe==3.0.2
-    # via
-    #   gradio
-    #   jinja2
-mcp==1.10.1
-    # via openai-agents
+mcp==1.14.1
 mdurl==0.1.2
-    # via markdown-it-py
-numpy==1.26.4
-    # via
-    #   gradio
-    #   pandas
-openai==1.91.0
-    # via
-    #   ankigen (pyproject.toml)
-    #   openai-agents
-openai-agents==0.1.0
-    # via ankigen (pyproject.toml)
+more-itertools==10.8.0
+numpy==2.3.1
+openai==1.109.1
+openai-agents==0.3.2
+openapi-core==0.19.5
+openapi-pydantic==0.5.1
+openapi-schema-validator==0.6.3
+openapi-spec-validator==0.7.2
 orjson==3.10.18
-    # via gradio
 packaging==25.0
-    # via
-    #   gradio
-    #   gradio-client
-    #   huggingface-hub
-pandas==2.2.3
-    # via
-    #   ankigen (pyproject.toml)
-    #   gradio
-pillow==11.3.0
-    # via gradio
-pydantic==2.10.6
-    # via
-    #   ankigen (pyproject.toml)
-    #   fastapi
-    #   gradio
-    #   mcp
-    #   openai
-    #   openai-agents
-    #   pydantic-settings
-pydantic-core==2.27.2
-    # via pydantic
+pandas==2.3.2
+parse==1.20.2
+pathable==0.4.4
+pillow==11.2.1
+pycparser==2.23
+pydantic==2.11.9
+pydantic-core==2.33.2
 pydantic-settings==2.10.1
-    # via mcp
 pydub==0.25.1
-    # via gradio
 pygments==2.19.2
-    # via rich
+pyperclip==1.10.0
 python-dateutil==2.9.0.post0
-    # via pandas
 python-dotenv==1.1.1
-    # via pydantic-settings
 python-multipart==0.0.20
-    # via
-    #   gradio
-    #   mcp
 pytz==2025.2
-    # via pandas
 pyyaml==6.0.2
-    # via
-    #   genanki
-    #   gradio
-    #   huggingface-hub
 referencing==0.36.2
-    # via
-    #   jsonschema
-    #   jsonschema-specifications
 regex==2024.11.6
-    # via tiktoken
 requests==2.32.4
-    # via
-    #   huggingface-hub
-    #   openai-agents
-    #   tiktoken
+rfc3339-validator==0.1.4
 rich==14.0.0
-    # via typer
+rich-rst==1.3.1
 rpds-py==0.26.0
-    # via
-    #   jsonschema
-    #   referencing
-ruff==0.12.0
-    # via gradio
+ruff==0.13.1
 safehttpx==0.1.6
-    # via gradio
 semantic-version==2.10.0
-    # via gradio
 shellingham==1.5.4
-    # via typer
 six==1.17.0
-    # via python-dateutil
 sniffio==1.3.1
-    # via
-    #   anyio
-    #   openai
 soupsieve==2.7
-    # via beautifulsoup4
 sse-starlette==2.3.6
-    # via mcp
 starlette==0.46.2
-    # via
-    #   fastapi
-    #   gradio
-    #   mcp
 tenacity==9.1.2
-    # via ankigen (pyproject.toml)
-tiktoken==0.9.0
-    # via ankigen (pyproject.toml)
+tiktoken==0.11.0
 tomlkit==0.13.3
-    # via gradio
 tqdm==4.67.1
-    # via
-    #   huggingface-hub
-    #   openai
 typer==0.16.0
-    # via gradio
 types-requests==2.32.4.20250611
-    # via openai-agents
 typing-extensions==4.14.0
-    # via
-    #   anyio
-    #   exceptiongroup
-    #   fastapi
-    #   gradio
-    #   gradio-client
-    #   huggingface-hub
-    #   openai
-    #   openai-agents
-    #   pydantic
-    #   pydantic-core
-    #   referencing
-    #   rich
-    #   typer
-    #   typing-inspection
-    #   uvicorn
 typing-inspection==0.4.1
-    # via pydantic-settings
 tzdata==2025.2
-    # via pandas
 urllib3==2.5.0
-    # via
-    #   requests
-    #   types-requests
 uvicorn==0.34.3
-    # via
-    #   gradio
-    #   mcp
 websockets==15.0.1
-    # via gradio-client
+werkzeug==3.1.1