Visual Mindmap Generation

def get_mindmap_crew():
    # Content Analyzer
    content_analyzer = Agent(
        name="Content Analyzer",
        role="Research Content Analyst",
        goal="Analyze research to identify main themes and hierarchical relationships up to 5 levels deep",
        backstory="""You are an expert content analyst who excels at 
                     breaking down complex research into logical hierarchical 
                     structures and identifying key relationships between 
                     concepts at multiple levels of detail.""",
        llm=llm,
        verbose=True
    )
    
    # Mindmap Creator
    mindmap_creator = Agent(
        name="Mindmap Creator",
        role="Mindmap Specialist",
        goal="Create final mindmap structure as nested dictionary with proper hierarchical relationships",
        backstory="""You are a mindmap specialist who transforms analyzed 
                     content into well-organized nested dictionary formats 
                     with clear hierarchical relationships and logical flow.""",
        llm=llm,
        verbose=True
    )
    
    return Crew(
        agents=[content_analyzer, mindmap_creator],
        tasks=[analyze_content_task, create_mindmap_task],
        process=Process.sequential,
        verbose=True,
    )

class SimpleMindmapStructure(BaseModel):
    mindmap: Dict[str, Any]  # Nested node structure
    title: str               # Mindmap title
    description: str         # Brief description

# Example node structure:
{
    "mindmap": {
        "id": "root",
        "text": "Main Research Topic",
        "display": {"block": True},
        "nodes": [
            {
                "id": "1",
                "text": "Category A",
                "nodes": [
                    {
                        "id": "2",
                        "text": "Subtopic 1",
                        "nodes": []
                    },
                    {
                        "id": "3",
                        "text": "Subtopic 2",
                        "nodes": []
                    }
                ]
            },
            {
                "id": "4",
                "text": "Category B",
                "nodes": []
            }
        ]
    },
    "title": "Research Topic Title",
    "description": "Brief description"
}

analyze_content_task = Task(
    description="""
    Analyze the research content and identify hierarchical themes with 
    appropriate depth (up to 5 levels):
    
    - Level 1: ONE main central topic/theme (the overarching subject)
    - Level 2: Primary categories under the main topic (3-6 major categories)
    - Level 3: Secondary subtopics under each category (2-5 per category)
    - Level 4: Detailed aspects (if content warrants it, 2-4 per subtopic)
    - Level 5: Specific details (only if highly detailed content, 1-3 per aspect)
    
    Determine the appropriate depth based on content complexity:
    - Simple content: 2-3 levels
    - Moderate content: 3-4 levels
    - Complex content: 4-5 levels
    
    Create a hierarchical breakdown with:
    - ONE main topic at the root level that encompasses the entire research
    - Concise labels (1-4 words each)
    - Logical grouping of related concepts under the main topic
    - Appropriate depth based on content richness
    - Clear parent-child relationships
    """,
    expected_output="""A hierarchical breakdown with appropriate depth 
                       (2-5 levels) based on content complexity, with concise 
                       labels and clear relationships.""",
    agent=content_analyzer
)

export function VisualMindmap({ mindmapData }: VisualMindmapProps) {
  const treeData = useMemo(() => {
    const getBlockStyleForLevel = (level: number): BlockNodeStyle => {
      switch (level % 5) {
        case 0: return "default";
        case 1: return "info";
        case 2: return "success";
        case 3: return "warn";
        case 4: return "danger";
        default: return "default";
      }
    };
    
    const processTreeNode = (node: TreeNode, level: number = 0): TreeNode => {
      return {
        id: node.id || `node-${Math.random()}`,
        text: node.text || "Unknown",
        display: {
          block: true,
          blockStyle: getBlockStyleForLevel(level),
        },
        nodes: node.nodes?.map(childNode => 
          processTreeNode(childNode, level + 1)
        ) || [],
      };
    };
    
    return processTreeNode(mindmapData.mindmap as unknown as TreeNode);
  }, [mindmapData]);
  
  return (
    <div className="w-full h-[700px] bg-gradient-to-br from-slate-50 to-slate-100">
      <Mindmap json={treeData} />
    </div>
  );
}

const [mindmap, setMindmap] = useState<string | null>(
  initialMindmap || null
);
const [isGenerating, setIsGenerating] = useState(false);

// Status values:
// - null: Not generated yet
// - "IN_PROGRESS": Currently generating
// - "ERROR": Generation failed
// - JSON string: Mindmap data (success)

useEffect(() => {
  if (mindmap !== "IN_PROGRESS") return;
  
  const pollInterval = setInterval(async () => {
    const response = await fetch(`/api/notebooks/${notebookId}`);
    const notebook = await response.json();
    const newMindmap = notebook.output?.mindmap;
    
    if (newMindmap && newMindmap !== "IN_PROGRESS") {
      setMindmap(newMindmap);
      
      if (newMindmap === "ERROR") {
        toast.error("Mindmap generation failed");
      } else {
        toast.success("Mindmap ready!");
      }
    }
  }, 3000);
  
  return () => clearInterval(pollInterval);
}, [mindmap, notebookId]);

POST /api/notebooks/[id]/mindmap

// Response
{
  "message": "Mindmap generation started"
}

// Database updates to "IN_PROGRESS"
// Backend processes asynchronously
// Poll GET /api/notebooks/[id] for completion