Refactor app.py to enhance concept graph visualization with improved error handling and response parsing. Integrate synchronous wrapper for async loading of concept graphs, update Gradio interface for better user experience, and streamline concept details display. Update concept graph tools to support LLM-driven generation with fallback mechanisms for concept retrieval.

app.py

@@ -3,19 +3,25 @@ Gradio web interface for the TutorX MCP Server with SSE support
 """
 
 import os
-import gradio as gr
-import numpy as np
 import json
-
-from datetime import datetime
 import asyncio
-import aiohttp
-import sseclient
+import gradio as gr
+from typing import Optional, Dict, Any, List, Union, Tuple
 import requests
+import tempfile
+import base64
+import re
+import networkx as nx
+import matplotlib
+import matplotlib.pyplot as plt
+
+# Set matplotlib to use 'Agg' backend to avoid GUI issues in Gradio
+matplotlib.use('Agg')
 
-# Import MCP SSE client context managers
-from mcp import ClientSession
+# Import MCP client components
 from mcp.client.sse import sse_client
+from mcp.client.session import ClientSession
+from mcp.types import TextContent, CallToolResult
 
 # Server configuration
 SERVER_URL = "http://localhost:8000/sse"  # Ensure this is the SSE endpoint
@@ -23,88 +29,270 @@ SERVER_URL = "http://localhost:8000/sse"  # Ensure this is the SSE endpoint
 # Utility functions
 
 
-async def load_concept_graph(concept_id: str = None):
+async def load_concept_graph(concept_id: str = None) -> Tuple[Optional[plt.Figure], Dict, List]:
     """
     Load and visualize the concept graph for a given concept ID.
     If no concept_id is provided, returns the first available concept.
-    Uses call_resource for concept graph retrieval (not a tool).
     
+    Args:
+        concept_id: The ID or name of the concept to load
+        
     Returns:
         tuple: (figure, concept_details, related_concepts) or (None, error_dict, [])
     """
+    print(f"[DEBUG] Loading concept graph for concept_id: {concept_id}")
+    
     try:
-        print(f"[DEBUG] Loading concept graph for concept_id: {concept_id}")
         async with sse_client(SERVER_URL) as (sse, write):
             async with ClientSession(sse, write) as session:
                 await session.initialize()
-                result = await session.call_tool("get_concept_graph_tool", {"concept_id": concept_id} if concept_id else {})
-                print(f"[DEBUG] Server response: {result}")
-                if not result or not isinstance(result, dict):
-                    error_msg = "Invalid server response"
+                
+                # Call the concept graph tool
+                result = await session.call_tool(
+                    "get_concept_graph_tool", 
+                    {"concept_id": concept_id} if concept_id else {}
+                )
+                print(f"[DEBUG] Raw tool response type: {type(result)}")
+                
+                # Extract content if it's a TextContent object
+                if hasattr(result, 'content') and isinstance(result.content, list):
+                    for item in result.content:
+                        if hasattr(item, 'text') and item.text:
+                            try:
+                                result = json.loads(item.text)
+                                print("[DEBUG] Successfully parsed JSON from TextContent")
+                                break
+                            except json.JSONDecodeError as e:
+                                print(f"[ERROR] Failed to parse JSON from TextContent: {e}")
+                
+                # If result is a string, try to parse it as JSON
+                if isinstance(result, str):
+                    try:
+                        result = json.loads(result)
+                    except json.JSONDecodeError as e:
+                        print(f"[ERROR] Failed to parse result as JSON: {e}")
+                        return None, {"error": f"Failed to parse concept graph data: {str(e)}"}, []
+                
+                # Debug print for the raw backend response
+                print(f"[DEBUG] Raw backend response: {result}")
+                
+                # Handle backend error response
+                if isinstance(result, dict) and "error" in result:
+                    error_msg = f"Backend error: {result['error']}"
                     print(f"[ERROR] {error_msg}")
                     return None, {"error": error_msg}, []
-                if "error" in result:
-                    print(f"[ERROR] Server returned error: {result['error']}")
-                    return None, {"error": result["error"]}, []
-                if "concepts" in result and not concept_id:
-                    if not result["concepts"]:
-                        error_msg = "No concepts available"
-                        print(f"[ERROR] {error_msg}")
-                        return None, {"error": error_msg}, []
-                    concept = result["concepts"][0]
-                    print(f"[DEBUG] Using first concept from list: {concept.get('id')}")
-                else:
-                    concept = result.get("concept", result)
-                    print(f"[DEBUG] Using direct concept: {concept.get('id')}")
-                if not isinstance(concept, dict) or not concept.get('id'):
-                    error_msg = "Invalid concept data structure"
-                    print(f"[ERROR] {error_msg}: {concept}")
+                
+                concept = None
+                
+                # Handle different response formats
+                if isinstance(result, dict):
+                    # Case 1: Direct concept object
+                    if "id" in result or "name" in result:
+                        concept = result
+                    # Case 2: Response with 'concepts' list
+                    elif "concepts" in result:
+                        if result["concepts"]:
+                            concept = result["concepts"][0] if not concept_id else None
+                            # Try to find the requested concept by ID or name
+                            if concept_id:
+                                for c in result["concepts"]:
+                                    if (isinstance(c, dict) and 
+                                        (c.get("id") == concept_id or 
+                                         str(c.get("name", "")).lower() == concept_id.lower())):
+                                        concept = c
+                                        break
+                                if not concept:
+                                    error_msg = f"Concept '{concept_id}' not found in the concept graph"
+                                    print(f"[ERROR] {error_msg}")
+                                    return None, {"error": error_msg}, []
+                        else:
+                            error_msg = "No concepts found in the concept graph"
+                            print(f"[ERROR] {error_msg}")
+                            return None, {"error": error_msg}, []
+                
+                # If we still don't have a valid concept
+                if not concept or not isinstance(concept, dict):
+                    error_msg = "Could not extract valid concept data from response"
+                    print(f"[ERROR] {error_msg}")
                     return None, {"error": error_msg}, []
-                import matplotlib.pyplot as plt
-                import networkx as nx
+                
+                # Ensure required fields exist with defaults
+                concept.setdefault('related_concepts', [])
+                concept.setdefault('prerequisites', [])
+                
+                print(f"[DEBUG] Final concept data: {concept}")
+                
+                # Create a new directed graph
                 G = nx.DiGraph()
-                G.add_node(concept["id"], label=concept["name"], type="concept")
-                related_concepts = []
-                if "related" in concept:
-                    for rel_id in concept["related"]:
-                        rel_result = await session.call_tool("get_concept_graph_tool", {"concept_id": rel_id})
-                        if "error" not in rel_result:
-                            rel_concept = rel_result.get("concept", {})
-                            G.add_node(rel_id, label=rel_concept.get("name", rel_id), type="related")
-                            G.add_edge(concept["id"], rel_id, relationship="related_to")
-                            related_concepts.append([rel_id, rel_concept.get("name", ""), rel_concept.get("description", "")])
-                if "prerequisites" in concept:
-                    for prereq_id in concept["prerequisites"]:
-                        prereq_result = await session.call_tool("get_concept_graph_tool", {"concept_id": prereq_id})
-                        if "error" not in prereq_result:
-                            prereq_concept = prereq_result.get("concept", {})
-                            G.add_node(prereq_id, label=prereq_concept.get("name", prereq_id), type="prerequisite")
-                            G.add_edge(prereq_id, concept["id"], relationship="prerequisite_for")
-                plt.figure(figsize=(10, 8))
-                pos = nx.spring_layout(G)
+                
+                # Add the main concept node
+                main_node_id = concept["id"]
+                G.add_node(main_node_id, 
+                          label=concept["name"], 
+                          type="main",
+                          description=concept["description"])
+                
+                # Add related concepts and edges
+                all_related = []
+                
+                # Process related concepts
+                for rel in concept.get('related_concepts', []):
+                    if isinstance(rel, dict):
+                        rel_id = rel.get('id', str(hash(str(rel.get('name', '')))))
+                        rel_name = rel.get('name', 'Unnamed')
+                        rel_desc = rel.get('description', 'Related concept')
+                        
+                        G.add_node(rel_id, 
+                                 label=rel_name, 
+                                 type="related",
+                                 description=rel_desc)
+                        G.add_edge(main_node_id, rel_id, type="related_to")
+                        
+                        all_related.append(["Related", rel_name, rel_desc])
+                
+                # Process prerequisites
+                for prereq in concept.get('prerequisites', []):
+                    if isinstance(prereq, dict):
+                        prereq_id = prereq.get('id', str(hash(str(prereq.get('name', '')))))
+                        prereq_name = f"[Prerequisite] {prereq.get('name', 'Unnamed')}"
+                        prereq_desc = prereq.get('description', 'Prerequisite concept')
+                        
+                        G.add_node(prereq_id,
+                                 label=prereq_name,
+                                 type="prerequisite",
+                                 description=prereq_desc)
+                        G.add_edge(prereq_id, main_node_id, type="prerequisite_for")
+                        
+                        all_related.append(["Prerequisite", prereq_name, prereq_desc])
+                
+                # Create the plot
+                plt.figure(figsize=(14, 10))
+                
+                # Calculate node positions using spring layout
+                pos = nx.spring_layout(G, k=0.5, iterations=50, seed=42)
+                
+                # Define node colors and sizes based on type
                 node_colors = []
-                for node in G.nodes():
-                    if G.nodes[node].get("type") == "concept":
-                        node_colors.append("lightblue")
-                    elif G.nodes[node].get("type") == "prerequisite":
-                        node_colors.append("lightcoral")
-                    else:
-                        node_colors.append("lightgreen")
-                nx.draw_networkx_nodes(G, pos, node_size=2000, node_color=node_colors, alpha=0.8)
-                nx.draw_networkx_edges(G, pos, width=1.0, alpha=0.5)
-                labels = {node: G.nodes[node].get("label", node) for node in G.nodes()}
-                nx.draw_networkx_labels(G, pos, labels, font_size=10, font_weight="bold")
-                edge_labels = {(u, v): d["relationship"] for u, v, d in G.edges(data=True)}
-                nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=8)
-                plt.title(f"Concept Graph: {concept.get('name', concept_id)}")
-                plt.axis("off")
-                concept_details = concept
-                return plt.gcf(), concept_details, related_concepts
+                node_sizes = []
+                for node, data in G.nodes(data=True):
+                    if data.get('type') == 'main':
+                        node_colors.append('#4e79a7')  # Blue for main concept
+                        node_sizes.append(1500)
+                    elif data.get('type') == 'prerequisite':
+                        node_colors.append('#59a14f')  # Green for prerequisites
+                        node_sizes.append(1000)
+                    else:  # related
+                        node_colors.append('#e15759')  # Red for related concepts
+                        node_sizes.append(1000)
+                
+                # Draw nodes
+                nx.draw_networkx_nodes(
+                    G, pos,
+                    node_color=node_colors,
+                    node_size=node_sizes,
+                    alpha=0.9,
+                    edgecolors='white',
+                    linewidths=2
+                )
+                
+                # Draw edges with different styles for different relationships
+                related_edges = [(u, v) for u, v, d in G.edges(data=True) 
+                              if d.get('type') == 'related_to']
+                prereq_edges = [(u, v) for u, v, d in G.edges(data=True) 
+                             if d.get('type') == 'prerequisite_for']
+                
+                # Draw related edges
+                nx.draw_networkx_edges(
+                    G, pos,
+                    edgelist=related_edges,
+                    width=1.5,
+                    alpha=0.7,
+                    edge_color="#e15759",
+                    style="solid",
+                    arrowsize=15,
+                    arrowstyle='-|>',
+                    connectionstyle='arc3,rad=0.1'
+                )
+                
+                # Draw prerequisite edges
+                nx.draw_networkx_edges(
+                    G, pos,
+                    edgelist=prereq_edges,
+                    width=1.5,
+                    alpha=0.7,
+                    edge_color="#59a14f",
+                    style="dashed",
+                    arrowsize=15,
+                    arrowstyle='-|>',
+                    connectionstyle='arc3,rad=0.1'
+                )
+                
+                # Draw node labels with white background for better readability
+                node_labels = {node: data["label"] 
+                             for node, data in G.nodes(data=True) 
+                             if "label" in data}
+                
+                nx.draw_networkx_labels(
+                    G, pos,
+                    labels=node_labels,
+                    font_size=10,
+                    font_weight="bold",
+                    font_family="sans-serif",
+                    bbox=dict(
+                        facecolor="white",
+                        edgecolor='none',
+                        alpha=0.8,
+                        boxstyle='round,pad=0.3',
+                        linewidth=0
+                    )
+                )
+                
+                # Add a legend
+                import matplotlib.patches as mpatches
+                legend_elements = [
+                    mpatches.Patch(facecolor='#4e79a7', label='Main Concept', alpha=0.9),
+                    mpatches.Patch(facecolor='#e15759', label='Related Concept', alpha=0.9),
+                    mpatches.Patch(facecolor='#59a14f', label='Prerequisite', alpha=0.9)
+                ]
+                
+                plt.legend(
+                    handles=legend_elements, 
+                    loc='upper right',
+                    bbox_to_anchor=(1.0, 1.0),
+                    frameon=True,
+                    framealpha=0.9
+                )
+                
+                plt.axis('off')
+                plt.tight_layout()
+                
+                # Create concept details dictionary
+                concept_details = {
+                    'name': concept['name'],
+                    'id': concept['id'],
+                    'description': concept['description']
+                }
+                
+                # Return the figure, concept details, and related concepts
+                return plt.gcf(), concept_details, all_related
+                
     except Exception as e:
         import traceback
-        traceback.print_exc()
+        error_msg = f"Error in load_concept_graph: {str(e)}\n\n{traceback.format_exc()}"
+        print(f"[ERROR] {error_msg}")
         return None, {"error": f"Failed to load concept graph: {str(e)}"}, []
-        
+
+def sync_load_concept_graph(concept_id):
+    """Synchronous wrapper for async load_concept_graph, always returns 3 outputs."""
+    try:
+        result = asyncio.run(load_concept_graph(concept_id))
+        if result and len(result) == 3:
+            return result
+        else:
+            return None, {"error": "Unexpected result format"}, []
+    except Exception as e:
+        return None, {"error": str(e)}, []
+
 # Create Gradio interface
 with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
     gr.Markdown("# 📚 TutorX Educational AI Platform")
@@ -122,43 +310,73 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
         with gr.Tab("Core Features"):
             with gr.Blocks() as concept_graph_tab:
                 gr.Markdown("## Concept Graph Visualization")
+                gr.Markdown("Explore relationships between educational concepts through an interactive graph visualization.")
+                
                 with gr.Row():
+                    # Left panel for controls and details
                     with gr.Column(scale=3):
-                        # Change from dropdown to textbox for concept input
-                        concept_input_box = gr.Textbox(
-                            label="Enter Concept Name",
-                            placeholder="e.g., python, functions, oop, data_structures",
-                            lines=1,
-                            interactive=True
-                        )
-                        load_concept_btn = gr.Button("Load Concept Graph", variant="primary")
+                        with gr.Row():
+                            concept_input = gr.Textbox(
+                                label="Enter Concept",
+                                placeholder="e.g., machine_learning, calculus, quantum_physics",
+                                value="machine_learning",
+                                scale=4
+                            )
+                            load_btn = gr.Button("Load Graph", variant="primary", scale=1)
                         
                         # Concept details
-                        concept_details = gr.JSON(label="Concept Details")
+                        with gr.Accordion("Concept Details", open=True):
+                            concept_details = gr.JSON(
+                                label=None,
+                                show_label=False
+                            )
                         
-                        # Related concepts
-                        related_concepts = gr.Dataframe(
-                            headers=["ID", "Name", "Description"],
-                            datatype=["str", "str", "str"],
-                            label="Related Concepts"
-                        )
+                        # Related concepts and prerequisites
+                        with gr.Accordion("Related Concepts & Prerequisites", open=True):
+                            related_concepts = gr.Dataframe(
+                                headers=["Type", "Name", "Description"],
+                                datatype=["str", "str", "str"],
+                                interactive=False,
+                                wrap=True,
+                                # max_height=300,  # Fixed height with scroll in Gradio 5.x
+                                # overflow_row_behaviour="paginate"
+                            )
                     
                     # Graph visualization
                     with gr.Column(scale=7):
-                        graph_output = gr.Plot(label="Concept Graph")
+                        graph_plot = gr.Plot(
+                            label="Concept Graph",
+                            show_label=True,
+                            container=True
+                        )
                 
-                # Button click handler
-                load_concept_btn.click(
-                    fn=load_concept_graph,
-                    inputs=[concept_input_box],
-                    outputs=[graph_output, concept_details, related_concepts]
+                # Event handlers
+                load_btn.click(
+                    fn=sync_load_concept_graph,
+                    inputs=[concept_input],
+                    outputs=[graph_plot, concept_details, related_concepts]
                 )
                 
-                # Load default concept on tab click
-                concept_graph_tab.load(
-                    fn=load_concept_graph,
-                    inputs=[concept_input_box],
-                    outputs=[graph_output, concept_details, related_concepts]
+                # Load initial graph
+                demo.load(
+                    fn=lambda: sync_load_concept_graph("machine_learning"),
+                    outputs=[graph_plot, concept_details, related_concepts]
+                )
+                # Help text and examples
+                with gr.Row():
+                    gr.Markdown("""
+                    **Examples to try:**
+                    - `machine_learning`
+                    - `neural_networks`
+                    - `calculus`
+                    - `quantum_physics`
+                    """)
+                
+                # Error display (leave in UI, but not wired up)
+                error_output = gr.Textbox(
+                    label="Error Messages",
+                    visible=False,
+                    interactive=False
                 )
             
             gr.Markdown("## Assessment Generation")

mcp_server/tools/concept_graph_tools.py

@@ -6,15 +6,7 @@ import sys
 import os
 from pathlib import Path
 import json
-
-# Add the parent directory to the Python path
-current_dir = Path(__file__).parent
-parent_dir = current_dir.parent.parent
-sys.path.insert(0, str(parent_dir))
-
-import sys
-import os
-from pathlib import Path
+import re
 
 # Add the parent directory to the Python path
 current_dir = Path(__file__).parent
@@ -30,25 +22,268 @@ from mcp_server.model.gemini_flash import GeminiFlash
 
 MODEL = GeminiFlash()
 
+
+USER_PROMPT_TEMPLATE = """You are an expert educational content creator and knowledge graph expert that helps create detailed concept graphs for educational purposes.
+Your task is to generate a comprehensive concept graph for a given topic, including related concepts and prerequisites.
+
+IMPORTANT: Output only valid JSON. Do not include any explanatory text before or after the JSON. Do not include comments. Do not include trailing commas. Double-check that your output is valid JSON and can be parsed by Python's json.loads().
+
+Output Format (JSON):
+{{
+  "concepts": [
+    {{
+      "id": "unique_concept_identifier",
+      "name": "Concept Name",
+      "description": "Clear and concise description of the concept",
+      "related_concepts": [
+        {{
+          "id": "related_concept_id",
+          "name": "Related Concept Name",
+          "description": "Brief description of the relationship"
+        }}
+      ],
+      "prerequisites": [
+        {{
+          "id": "prerequisite_id",
+          "name": "Prerequisite Concept Name",
+          "description": "Why this is a prerequisite"
+        }}
+      ]
+    }}
+  ]
+}}
+
+Guidelines:
+1. Keep concept IDs lowercase with underscores (snake_case)
+2. Include 1 related concepts and 1 prerequisites per concept
+3. Ensure descriptions are educational and concise
+4. Maintain consistency in the knowledge domain
+5. Include fundamental concepts even if not directly mentioned
+
+Generate a detailed concept graph for: {concept}
+
+Focus on {domain} concepts and provide a comprehensive graph with related concepts and prerequisites.
+Include both broad and specific concepts relevant to this topic.
+
+Remember: Return only valid JSON, no additional text. Do not include trailing commas. Do not include comments. Double-check your output is valid JSON."""
+
+# Sample concept graph as fallback
+SAMPLE_CONCEPT_GRAPH = {
+    "concepts": [
+        {
+            "id": "machine_learning",
+            "name": "Machine Learning",
+            "description": "A branch of artificial intelligence that focuses on algorithms that can learn from and make predictions on data",
+            "related_concepts": [
+                {
+                    "id": "artificial_intelligence",
+                    "name": "Artificial Intelligence",
+                    "description": "The broader field that encompasses machine learning"
+                },
+                {
+                    "id": "deep_learning",
+                    "name": "Deep Learning",
+                    "description": "A subset of machine learning using neural networks"
+                }
+            ],
+            "prerequisites": [
+                {
+                    "id": "statistics",
+                    "name": "Statistics",
+                    "description": "Understanding of statistical concepts is fundamental"
+                }
+            ]
+        }
+    ]
+}
+
+def clean_json_trailing_commas(json_text: str) -> str:
+    # Remove trailing commas before } or ]
+    return re.sub(r',([ \t\r\n]*[}}\]])', r'\1', json_text)
+
+def extract_json_from_text(text: str) -> Optional[dict]:
+    if not text or not isinstance(text, str):
+        return None
+
+    try:
+        # Remove all code fences (``` or ```json) at the start/end, with optional whitespace
+        text = re.sub(r'^\s*```(?:json)?\s*', '', text, flags=re.IGNORECASE)
+        text = re.sub(r'\s*```\s*$', '', text, flags=re.IGNORECASE)
+        text = text.strip()
+
+        print(f"[DEBUG] LLM output ends with: {text[-500:]}")
+
+        # Remove trailing commas
+        cleaned = clean_json_trailing_commas(text)
+
+        # Parse JSON
+        return json.loads(cleaned)
+    except Exception as e:
+        print(f"[DEBUG] Failed JSON extraction: {e}")
+        return None
+
+
+async def generate_text(prompt: str, temperature: float = 0.7):
+    """Generate text using the configured model."""
+    try:
+        print(f"[DEBUG] Calling MODEL.generate_text with prompt length: {len(prompt)}")
+        print(f"[DEBUG] MODEL type: {type(MODEL)}")
+        
+        # Check if the model has the expected method
+        if not hasattr(MODEL, 'generate_text'):
+            print(f"[DEBUG] MODEL does not have generate_text method. Available methods: {dir(MODEL)}")
+            raise AttributeError("MODEL does not have generate_text method")
+        
+        # This should call your actual model generation method
+        # Adjust this based on your GeminiFlash implementation
+        response = await MODEL.generate_text(
+            prompt=prompt,
+            temperature=temperature
+        )
+        print(f"[DEBUG] generate_text response type: {type(response)}")
+        return response
+    except Exception as e:
+        print(f"[DEBUG] Error in generate_text: {e}")
+        print(f"[DEBUG] Error type: {type(e)}")
+        raise
+
+
 @mcp.tool()
-async def get_concept_graph_tool(concept_id: Optional[str] = None) -> dict:
+async def get_concept_graph_tool(concept_id: Optional[str] = None, domain: str = "computer science") -> dict:
     """
-    Get the complete concept graph or a specific concept, fully LLM-driven.
-    For a specific concept, use Gemini to generate a JSON object with explanation, related concepts, prerequisites, and summary.
-    For the full graph, use Gemini to generate a JSON object with a list of all concepts and their relationships.
+    Generate or retrieve a concept graph for a given concept ID or name.
+    
+    Args:
+        concept_id: The ID or name of the concept to retrieve
+        domain: The knowledge domain (e.g., 'computer science', 'mathematics')
+    
+    Returns:
+        dict: A single concept dictionary with keys: id, name, description, related_concepts, prerequisites
     """
-    if concept_id:
-        prompt = (
-            f"Provide a JSON object for the concept '{concept_id}' with fields: explanation (string), related_concepts (list of strings), prerequisites (list of strings), and summary (string)."
-        )
-    else:
-        prompt = (
-            "Provide a JSON object with a list of all concepts in a knowledge graph. "
-            "Each concept should have fields: id, name, description, related_concepts (list), prerequisites (list)."
-        )
-    llm_response = await MODEL.generate_text(prompt)
+    print(f"[DEBUG] get_concept_graph_tool called with concept_id: {concept_id}, domain: {domain}")
+    
+    if not concept_id:
+        print(f"[DEBUG] No concept_id provided, returning sample concept")
+        return SAMPLE_CONCEPT_GRAPH["concepts"][0]
+    
+    # Create a fallback custom concept based on the requested concept_id
+    fallback_concept = {
+        "id": concept_id.lower().replace(" ", "_"),
+        "name": concept_id.title(),
+        "description": f"A {domain} concept related to {concept_id}",
+        "related_concepts": [
+            {
+                "id": "related_concept_1",
+                "name": "Related Concept 1",
+                "description": f"A concept related to {concept_id}"
+            },
+            {
+                "id": "related_concept_2", 
+                "name": "Related Concept 2",
+                "description": f"Another concept related to {concept_id}"
+            }
+        ],
+        "prerequisites": [
+            {
+                "id": "basic_prerequisite",
+                "name": "Basic Prerequisite",
+                "description": f"Basic knowledge required for understanding {concept_id}"
+            }
+        ]
+    }
+    
+    # Try LLM generation first, fallback to custom concept if it fails
     try:
-        data = json.loads(llm_response)
-    except Exception:
-        data = {"llm_raw": llm_response, "error": "Failed to parse LLM output as JSON"}
-    return data
+        print(f"[DEBUG] Attempting LLM generation for: {concept_id} in domain: {domain}")
+        
+        # Generate the concept graph using LLM
+        prompt = USER_PROMPT_TEMPLATE.format(concept=concept_id, domain=domain)
+        print(f"[DEBUG] Prompt created, length: {len(prompt)}")
+        
+        try:
+            # Call the LLM to generate the concept graph
+            print(f"[DEBUG] About to call generate_text...")
+            response = await generate_text(
+                prompt=prompt,
+                temperature=0.7
+            )
+            print(f"[DEBUG] generate_text completed successfully")
+            
+        except Exception as gen_error:
+            print(f"[DEBUG] Error in generate_text call: {gen_error}")
+            print(f"[DEBUG] Returning fallback concept due to generation error")
+            return fallback_concept
+        
+        # Extract and validate the JSON response
+        print(f"[DEBUG] Full LLM response object type: {type(response)}")
+        
+        # Handle different response formats
+        response_text = None
+        try:
+            if hasattr(response, 'content'):
+                if isinstance(response.content, list) and response.content:
+                    if hasattr(response.content[0], 'text'):
+                        response_text = response.content[0].text
+                    else:
+                        response_text = str(response.content[0])
+                elif isinstance(response.content, str):
+                    response_text = response.content
+            elif hasattr(response, 'text'):
+                response_text = response.text
+            elif isinstance(response, str):
+                response_text = response
+            else:
+                response_text = str(response)
+                
+            print(f"[DEBUG] Extracted response_text type: {type(response_text)}")
+            print(f"[DEBUG] Response text length: {len(response_text) if response_text else 0}")
+            
+        except Exception as extract_error:
+            print(f"[DEBUG] Error extracting response text: {extract_error}")
+            print(f"[DEBUG] Returning fallback concept due to extraction error")
+            return fallback_concept
+        
+        if not response_text:
+            print(f"[DEBUG] LLM response is empty, returning fallback concept")
+            return fallback_concept
+        
+        print(f"[DEBUG] LLM raw response text (first 200 chars): {response_text}...")
+        
+        try:
+            result = extract_json_from_text(response_text)
+            print(f"[DEBUG] JSON extraction result: {result is not None}")
+            if result:
+                print(f"[DEBUG] Extracted JSON keys: {result.keys() if isinstance(result, dict) else 'Not a dict'}")
+        except Exception as json_error:
+            print(f"[DEBUG] Error in extract_json_from_text: {json_error}")
+            print(f"[DEBUG] Returning fallback concept due to JSON extraction error")
+            return fallback_concept
+        
+        if not result:
+            print(f"[DEBUG] No valid JSON extracted, returning fallback concept")
+            return fallback_concept
+        
+        if "concepts" in result and isinstance(result["concepts"], list) and result["concepts"]:
+            print(f"[DEBUG] Found {len(result['concepts'])} concepts in LLM response")
+            # Find the requested concept or return the first
+            for concept in result["concepts"]:
+                if (concept.get("id") == concept_id or 
+                    concept.get("name", "").lower() == concept_id.lower()):
+                    print(f"[DEBUG] Found matching LLM concept: {concept.get('name')}")
+                    return concept
+            # If not found, return the first concept
+            first_concept = result["concepts"][0]
+            print(f"[DEBUG] Concept not found, returning first LLM concept: {first_concept.get('name')}")
+            return first_concept
+        else:
+            print(f"[DEBUG] LLM JSON does not contain valid 'concepts' list, returning fallback")
+            return fallback_concept
+        
+    except Exception as e:
+        import traceback
+        error_msg = f"Error generating concept graph: {str(e)}"
+        print(f"[DEBUG] Exception in get_concept_graph_tool: {error_msg}")
+        print(f"[DEBUG] Full traceback: {traceback.format_exc()}")
+        # Return fallback concept instead of error
+        print(f"[DEBUG] Returning fallback concept due to exception")
+        return fallback_concept