Abstract

✨ LearnMate is a multi-agent system that can spin up comprehensive, visually structured wikis on any topic in minutes. It brings together a team of specialized AI agents that research, plan, write, and add diagrams, so the final output feels like a clean wiki page built just for you. With two-phase research, parallel content and visual generation, and built-in checkpointing so you can pick up right where you left off, LearnMate is designed to be both powerful and practical. This publication explains the motivation, design, and methodology behind LearnMate, along with setup details, evaluation results, and future scope.

1. Introduction & Purpose

😓 Pulling together knowledge from scratch is tedious: you hop between docs, blogs, and videos, and still end up with something unstructured. Even when resources are solid, they often lack diagrams or clear flow. Meanwhile, single-agent AI tools can draft text but fall short on structured outputs and visuals.

📊 LearnMate addresses this challenge by orchestrating multiple agents with distinct roles—research, planning, writing, and visual design. The result is a well-organized wiki that combines textual depth with diagrams, images and tables. By the end of this publication, readers will understand how LearnMate is built, how to set it up and use it, and how its design decisions enable modularity, resilience, and speed.

1.1 UI Screenshots

Figure 1: Streamlit interface with topic input, wiki viewer, and state upload options. Figure 2: The generated wiki showing an image pulled from the web by the Design agent. Figure 3: The generated wiki showing a table and mermaid diagram generated by the Design agent.

2. Objectives of the Publication

🎯 This publication provides a comprehensive overview of LearnMate’s design and operation. Key objectives:

• Setup & Usage: Instructions for installation, running, and configuration.
• Architecture & Methodology: How agents coordinate to produce structured content and visuals.
• State Management & Orchestration: How checkpointing and resumability improve robustness.
• Evaluation & Results: Insights into output quality, efficiency, and resilience.
• Limitations & Future Scope: Current trade-offs and planned extensions.

3. Intended Audience & Use Case

📘 LearnMate is designed for:

• Learners and educators: anyone who needs crisp, structured explainers.
• AI/ML enthusiasts: those exploring agentic workflows and orchestration.

It is particularly useful for:

• 📝 Creating study notes and tutorials.
• 📂 Preparing onboarding guides and structured documentation.
• 📊 Generating visual-rich technical explainers.

💡 Tip: Users can upload a saved state file in the Streamlit UI to resume from a specific step—or even edit the state file to retry from that node.

Prerequisites: Python 3.11+, an OpenAI or Groq API key, and basic familiarity with CLI or Streamlit.

4. Setup & Usage

4.1 🚀 Quick Start

1. 📦 Set up dependencies (choose one):

   # Recommended: using uv
   pip install uv  # if uv is not installed
   uv venv
   source .venv/bin/activate   # MacOS/Linux
   # or
   .venv\Scripts\activate   # Windows
   uv sync
   
   # Alternative: using pip
   python -m venv .venv
   source .venv/bin/activate   # MacOS/Linux
   # or
   .venv\Scripts\activate   # Windows
   pip install -r requirements.txt

2. 🎬 Run the Streamlit UI:

   streamlit run frontend/app.py

   This launches a browser interface where you can enter a topic, generate a wiki, and manage saved states.

3. 🔄 Resume from a saved state (optional):

The pipeline saves state after each successful node. If a run is interrupted, you can resume from the last checkpoint by uploading the saved state file from the sidebar.

The saved state file will be placed at outputs/Your_Topic/saved_wiki_state.json.

You can also manually edit the state file to modify or retry specific steps.

4.2 ⚙️ Configuration Options

Configuration is managed in config/config.yaml:

• research_model_llm: model for the initial research phase.
• planner_model_llm: model for planning the content structure.
• content_writer_model_llm: model for generating wiki text.
• design_coder_model_llm: model for generating diagrams/tables.
• mermaid_api_base_url: rendering service URL (default https://mermaid.ink, can be changed to a local server like http://localhost:3000).
• reasoning_strategies: named strategies (e.g., CoT, ReAct, Self-Ask) referenced in prompts.

UI theme customization via .streamlit/config.toml:

• primaryColor, backgroundColor, secondaryBackgroundColor, textColor, font.

Environment variables (.env or system):

• TAVILY_API_KEY (required)
• OPENAI_API_KEY or GROQ_API_KEY (at least one is required)

5. Related Work & Background

🔎 Existing projects like LangChain Agents, AutoGPT, and BabyAGI highlight the potential of LLM-powered workflows. However, they often:

• Produce unstructured or verbose outputs.
• Lack integrated visual generation.
• Miss checkpointing features for resumability.

LearnMate bridges these gaps by combining structured orchestration, visual generation, and robust state management.

6. Architecture & Methodology

Figure 4: Multi-Agent Architecture Flowchart

6.1 High-Level Workflow

User Input → Research → Planning → (Content Writing || Visual Design) → Merging → Final Wiki

📐 A flowchart (available in the repository) illustrates how research feeds into planning, which then branches into parallel writing and design before merging into the final output.

6.2 Agent Roles

• Research Agent: two-phase exploration (overview + deep dive).
• Planner Agent: drafts the wiki outline and maps visuals.
• Content Writer Agent: generates structured text.
• Design Coder Agent: produces diagrams (Mermaid), tables, and image references. Uses a validator tool to ensure Mermaid syntax correctness.
• Content Validation Layer (planned): will fact-check and grammar-check generated text.

6.3 State Management

• Progress saved as JSON after each step.
• Resume via CLI (--state) or Streamlit UI.
• State files can be edited to retry specific nodes.

6.4 Parallel Processing & Performance

⚡ Writer and designer agents run in parallel, significantly reducing total runtime.

6.5 Design Decisions

A multi-agent setup was chosen for modularity and resilience. A monolithic pipeline was tested but proved harder to extend and debug.

6.6 Assumptions

• Users have access to reliable LLM APIs.
• Research sources provide adequate coverage for the chosen topic.

7. Licensing, Support & Operational Considerations

• License: Apache 2.0
• Repository: https://github.com/rishi255/learnmate
• Contact:  rishikeshrachchh@gmail.com (issues via GitHub Issues)
• Resource Needs: Minimal since we are using an API.

8. Implementation Details

• Backend: Python + LangGraph.
• Frontend: Streamlit app with topic input, wiki viewer, and state upload.
• Tools: LLMs (OpenAI/Groq), Mermaid, YAML configs.
• Config: managed via config.yaml.
• Environment: Python 3.11, uv or pip for dependencies.
• Repository: GitHub – LearnMate

9. Results & Evaluation

• Quality: Wikis were logically structured and enriched with diagrams, tables, and images pulled from the web.
• Performance: Parallel execution reduced runtime compared to sequential generation.
• Resilience: Checkpointing allowed recovery from failed runs.

⏳ Compared to a single-agent baseline, LearnMate outputs were more structured, easier to navigate, and visually informative.

10. Limitations & Trade-offs

• Output accuracy still depends on the underlying LLM.
• Validation agents are not fully implemented yet.
• Mermaid rendering can fail if external services are unavailable.
• Works best for technical topics.

11. Future Work

• ☑️ Introduce validation agents for fact-checking.
• 🎨 Expand visual capabilities (AI images, interactive diagrams).
• 🎧 Enhance UI with feedback options, navigation tools, and text-to-speech.
• ⚖️ Adapt the system to specialized domains like healthcare, law, and finance.

12. Conclusion

📚 LearnMate demonstrates how multi-agent AI can transform a simple topic request into a polished wiki complete with structured text and diagrams. Its modular design, checkpointing, and parallelism provide a solid blueprint for future agentic workflows in knowledge-intensive domains.

13. References

• LangChain Docs – https://python.langchain.com/docs/introduction/
• LangGraph Docs – https://langchain-ai.github.io/langgraph/
• AutoGPT – https://github.com/Torantulino/Auto-GPT
• BabyAGI – https://github.com/yoheinakajima/babyagi
• Streamlit – https://docs.streamlit.io
• Mermaid – https://mermaid.js.org