Extend Sample Traces for Realistic AI Assistant Interactions - Multi-step RAG workflow with 4 observations, extended educational conversations, enhanced knowledge graph interactions, and production-quality AI assistant demonstrations

backend/database/sample_data.py

@@ -15,7 +15,7 @@ SAMPLE_TRACES = [
     {
         "filename": "python_documentation_inquiry.json",
         "title": "Python Documentation Assistant Demo",
-        "description": "Enhanced example showing RAG-powered AI assistant processing programming inquiry with knowledge search, failure detection and optimization suggestions",
+        "description": "Comprehensive example showing RAG-powered AI assistant handling multi-turn programming inquiry with knowledge search, detailed explanations, code examples, performance analysis, and interactive learning",
         "trace_type": "documentation_search",
         "trace_source": "sample_data",
         "tags": ["programming", "rag_assistant", "documentation", "failure_detection", "optimization"],
@@ -28,45 +28,90 @@ SAMPLE_TRACES = [
     "converted_at": "2025-01-27T12:00:00.000000"
   },
   "data": {
-    "total_observations": 1,
-    "summary": "Python documentation inquiry with RAG-powered assistant response"
+    "total_observations": 4,
+    "summary": "Python documentation inquiry with RAG-powered assistant response including knowledge search, explanation, and follow-up code examples"
   },
   "observations": [
     {
       "id": "demo_obs_001",
-      "type": "inference",
+      "type": "user_query",
       "timestamp": "2025-01-27T00:00:00",
-      "input": "You are a helpful Python programming assistant designed to answer questions accurately based on the provided documentation. Use the information retrieved from the knowledge base below to respond concisely and correctly.\\n\\n### Retrieved Documents:\\n['Python list comprehensions - efficient way to create lists', 'Python built-in functions - len(), range(), enumerate()', 'Python data structures - lists, dictionaries, sets, tuples']\\n\\n### Question:\\nwhat are python list comprehensions used for?\\n\\n### Answer:",
-      "output": "Python list comprehensions provide an efficient and readable way to create lists by applying expressions to elements in iterables.",
+      "input": "Hello! I'm learning Python and I keep seeing this syntax with square brackets that looks different from regular loops. Can you help me understand what Python list comprehensions are used for and when I should use them?",
+      "output": "I'll help you understand Python list comprehensions! Let me search our documentation to give you a comprehensive explanation.",
+      "metadata": {
+        "request_date": "2025-01-27T00:00:00",
+        "interaction_type": "initial_query",
+        "user_level": "beginner",
+        "topic_category": "python_syntax"
+      },
+      "latency": 0.124
+    },
+    {
+      "id": "demo_obs_002",
+      "type": "knowledge_search",
+      "timestamp": "2025-01-27T00:00:05",
+      "input": "Searching Python documentation for: list comprehensions, syntax, use cases, performance benefits",
+      "output": "Found relevant documentation: ['Python list comprehensions - efficient way to create lists', 'List comprehension vs loops performance comparison', 'Python built-in functions - len(), range(), enumerate()', 'Nested list comprehensions and filtering', 'Python data structures - lists, dictionaries, sets, tuples']",
+      "metadata": {
+        "search_query": "python list comprehensions syntax use cases",
+        "documents_found": 5,
+        "search_time_ms": 23,
+        "relevance_score": 0.94
+      },
+      "latency": 0.089
+    },
+    {
+      "id": "demo_obs_003",
+      "type": "inference",
+      "timestamp": "2025-01-27T00:00:08",
+      "input": "You are a helpful Python programming assistant designed to answer questions accurately based on the provided documentation. Use the information retrieved from the knowledge base below to respond concisely and correctly.\\n\\n### Retrieved Documents:\\n['Python list comprehensions - efficient way to create lists', 'List comprehension vs loops performance comparison', 'Python built-in functions - len(), range(), enumerate()', 'Nested list comprehensions and filtering']\\n\\n### Question:\\nwhat are python list comprehensions used for and when should I use them?\\n\\n### Answer:",
+      "output": "Python list comprehensions are a powerful and concise way to create lists! Here's what they're used for:\\n\\n**Main Uses:**\\n1. **Creating lists from existing iterables** - Transform elements from sequences\\n2. **Filtering data** - Include only elements that meet specific conditions\\n3. **Mathematical operations** - Apply calculations efficiently\\n4. **Combining operations** - Filter and transform in one line\\n\\n**When to use them:**\\n- When you need to create a new list from an existing iterable\\n- For simple transformations (keep it readable!)\\n- When performance matters (they're faster than equivalent for loops)\\n- To make code more Pythonic and concise\\n\\n**Basic syntax:** `[expression for item in iterable if condition]`",
       "metadata": {
         "request_date": "2025-01-27T00:00:00",
-        "databricks_request_id": "demo-request-001",
-        "request_time": "2025-01-27T12:00:00.000",
+        "databricks_request_id": "demo-request-003",
+        "request_time": "2025-01-27T12:00:08.000",
         "status_code": 200,
         "sampling_fraction": 1,
-        "request_raw": "{\"messages\":[{\"role\":\"system\",\"content\":\"You are a helpful Python programming assistant\"},{\"role\":\"user\",\"content\":\"You are a helpful Python programming assistant designed to answer questions accurately based on the provided documentation. Use the information retrieved from the knowledge base below to respond concisely and correctly.\\\\n\\\\n### Retrieved Documents:\\\\n['Python list comprehensions - efficient way to create lists', 'Python built-in functions - len(), range(), enumerate()', 'Python data structures - lists, dictionaries, sets, tuples']\\\\n\\\\n### Question:\\\\nwhat are python list comprehensions used for?\\\\n\\\\n### Answer:\"}]}",
-        "response_raw": "{\"choices\":[{\"content_filter_results\":{\"hate\":{\"filtered\":false,\"severity\":\"safe\"},\"self_harm\":{\"filtered\":false,\"severity\":\"safe\"},\"sexual\":{\"filtered\":false,\"severity\":\"safe\"},\"violence\":{\"filtered\":false,\"severity\":\"safe\"}},\"finish_reason\":\"stop\",\"index\":0,\"logprobs\":null,\"message\":{\"content\":\"Python list comprehensions provide an efficient and readable way to create lists by applying expressions to elements in iterables.\",\"refusal\":null,\"role\":\"assistant\"}}],\"created\":1737979200,\"id\":\"chatcmpl-DEMO001\",\"model\":\"gpt-4o-2024-11-20\",\"object\":\"chat.completion\",\"system_fingerprint\":\"fp_demo_001\",\"usage\":{\"completion_tokens\":22,\"completion_tokens_details\":{\"accepted_prediction_tokens\":0,\"audio_tokens\":0,\"reasoning_tokens\":0,\"rejected_prediction_tokens\":0},\"prompt_tokens\":168,\"prompt_tokens_details\":{\"audio_tokens\":0,\"cached_tokens\":0},\"total_tokens\":190}}",
-        "served_entity_id": "demo-entity-001",
+        "request_raw": "{\"messages\":[{\"role\":\"system\",\"content\":\"You are a helpful Python programming assistant\"},{\"role\":\"user\",\"content\":\"You are a helpful Python programming assistant designed to answer questions accurately based on the provided documentation. Use the information retrieved from the knowledge base below to respond concisely and correctly.\\\\n\\\\n### Retrieved Documents:\\\\n['Python list comprehensions - efficient way to create lists', 'List comprehension vs loops performance comparison', 'Python built-in functions - len(), range(), enumerate()', 'Nested list comprehensions and filtering']\\\\n\\\\n### Question:\\\\nwhat are python list comprehensions used for and when should I use them?\\\\n\\\\n### Answer:\"}]}",
+        "response_raw": "{\"choices\":[{\"content_filter_results\":{\"hate\":{\"filtered\":false,\"severity\":\"safe\"},\"self_harm\":{\"filtered\":false,\"severity\":\"safe\"},\"sexual\":{\"filtered\":false,\"severity\":\"safe\"},\"violence\":{\"filtered\":false,\"severity\":\"safe\"}},\"finish_reason\":\"stop\",\"index\":0,\"logprobs\":null,\"message\":{\"content\":\"Python list comprehensions are a powerful and concise way to create lists! Here's what they're used for:\\\\n\\\\n**Main Uses:**\\\\n1. **Creating lists from existing iterables** - Transform elements from sequences\\\\n2. **Filtering data** - Include only elements that meet specific conditions\\\\n3. **Mathematical operations** - Apply calculations efficiently\\\\n4. **Combining operations** - Filter and transform in one line\\\\n\\\\n**When to use them:**\\\\n- When you need to create a new list from an existing iterable\\\\n- For simple transformations (keep it readable!)\\\\n- When performance matters (they're faster than equivalent for loops)\\\\n- To make code more Pythonic and concise\\\\n\\\\n**Basic syntax:** `[expression for item in iterable if condition]`\",\"refusal\":null,\"role\":\"assistant\"}}],\"created\":1737979208,\"id\":\"chatcmpl-DEMO003\",\"model\":\"gpt-4o-2024-11-20\",\"object\":\"chat.completion\",\"system_fingerprint\":\"fp_demo_003\",\"usage\":{\"completion_tokens\":156,\"completion_tokens_details\":{\"accepted_prediction_tokens\":0,\"audio_tokens\":0,\"reasoning_tokens\":0,\"rejected_prediction_tokens\":0},\"prompt_tokens\":184,\"prompt_tokens_details\":{\"audio_tokens\":0,\"cached_tokens\":0},\"total_tokens\":340}}",
+        "served_entity_id": "demo-entity-003",
         "logging_error_codes": "[]",
         "requester": "demo-user-001"
       },
-      "latency": 0.531,
+      "latency": 1.247,
       "usage": {
-        "completion_tokens": 22,
+        "completion_tokens": 156,
         "completion_tokens_details": {
           "accepted_prediction_tokens": 0,
           "audio_tokens": 0,
           "reasoning_tokens": 0,
           "rejected_prediction_tokens": 0
         },
-        "prompt_tokens": 168,
+        "prompt_tokens": 184,
         "prompt_tokens_details": {
           "audio_tokens": 0,
           "cached_tokens": 0
         },
-        "total_tokens": 190
+        "total_tokens": 340
       },
       "model": "gpt-4o-2024-11-20"
+    },
+    {
+      "id": "demo_obs_004",
+      "type": "follow_up",
+      "timestamp": "2025-01-27T00:00:15",
+      "input": "That's really helpful! Could you show me some practical examples? I'd love to see the difference between a regular for loop and a list comprehension.",
+      "output": "Absolutely! Here are some practical examples:\\n\\n**Example 1: Squaring numbers**\\n```python\\n# Traditional for loop\\nsquares = []\\nfor x in range(5):\\n    squares.append(x**2)\\n# Result: [0, 1, 4, 9, 16]\\n\\n# List comprehension\\nsquares = [x**2 for x in range(5)]\\n# Same result: [0, 1, 4, 9, 16]\\n```\\n\\n**Example 2: Filtering even numbers**\\n```python\\n# Traditional approach\\nevens = []\\nfor x in range(10):\\n    if x % 2 == 0:\\n        evens.append(x)\\n\\n# List comprehension\\nevens = [x for x in range(10) if x % 2 == 0]\\n# Result: [0, 2, 4, 6, 8]\\n```\\n\\n**Example 3: String processing**\\n```python\\nwords = ['hello', 'world', 'python']\\n# Capitalize and get lengths\\nlengths = [len(word.upper()) for word in words]\\n# Result: [5, 5, 6]\\n```\\n\\nList comprehensions are not only more concise but also typically 20-30% faster than equivalent for loops!",
+      "metadata": {
+        "interaction_type": "follow_up_examples",
+        "code_examples_provided": 3,
+        "response_time": "2025-01-27T12:00:15.000"
+      },
+      "latency": 0.892,
+      "usage": {
+        "completion_tokens": 287,
+        "total_tokens": 445
+      }
     }
   ]
 }"""
@@ -74,10 +119,10 @@ SAMPLE_TRACES = [
     {
         "filename": "simple_qa_demonstration.txt",
         "title": "Simple Q&A: Basic Programming Help",
-        "description": "Streamlined example showing basic programming assistant interaction with clear knowledge graph structure",
+        "description": "Extended example showing interactive programming assistant with multi-turn educational conversation, step-by-step explanations, and performance comparisons",
         "trace_type": "conversation",
         "trace_source": "sample_data",
-        "tags": ["simple", "qa", "basic", "demonstration"],
+        "tags": ["detailed", "qa", "educational", "interactive", "performance"],
         "content": """User: Hello, can you help me understand what Python list comprehensions are used for?
 
 Assistant: Certainly! Python list comprehensions are a powerful and concise way to create lists. Here are their main uses:
@@ -89,7 +134,74 @@ Assistant: Certainly! Python list comprehensions are a powerful and concise way
 
 For example: `[x**2 for x in range(10) if x % 2 == 0]` creates a list of squares of even numbers.
 
-Would you like to see more specific examples or learn about related Python features?"""
+Would you like to see more specific examples or learn about related Python features?
+
+User: Yes, that example looks interesting! Can you break down how that specific example works step by step?
+
+Assistant: Absolutely! Let me break down `[x**2 for x in range(10) if x % 2 == 0]` step by step:
+
+**Step 1: The iterable**
+- `range(10)` generates numbers: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
+
+**Step 2: The condition (filter)**
+- `if x % 2 == 0` keeps only even numbers
+- This filters to: 0, 2, 4, 6, 8
+
+**Step 3: The expression (transformation)**
+- `x**2` squares each remaining number
+- Results in: 0², 2², 4², 6², 8² = 0, 4, 16, 36, 64
+
+**Final result**: `[0, 4, 16, 36, 64]`
+
+**Equivalent traditional loop:**
+```python
+result = []
+for x in range(10):
+    if x % 2 == 0:
+        result.append(x**2)
+```
+
+The list comprehension does the same thing in just one readable line!
+
+User: That makes so much sense now! Are there any performance differences between the two approaches?
+
+Assistant: Great question! Yes, there are notable performance differences:
+
+**Performance Benefits of List Comprehensions:**
+
+1. **Speed**: List comprehensions are typically 20-30% faster than equivalent for loops
+   - They're implemented in C under the hood
+   - Less Python bytecode overhead
+
+2. **Memory efficiency**: More memory-efficient during creation
+   - Pre-allocates the result list size when possible
+   - Fewer intermediate steps
+
+**Quick benchmark example:**
+```python
+import timeit
+
+# List comprehension
+time1 = timeit.timeit('[x**2 for x in range(1000)]', number=10000)
+
+# Traditional loop
+code = '''
+result = []
+for x in range(1000):
+    result.append(x**2)
+'''
+time2 = timeit.timeit(code, number=10000)
+
+print(f"List comprehension: {time1:.4f}s")
+print(f"Traditional loop: {time2:.4f}s")
+# Typical result: comprehension is ~25% faster
+```
+
+**When to use each:**
+- **List comprehensions**: Simple transformations, filtering, mathematical operations
+- **Traditional loops**: Complex logic, multiple statements, debugging needs
+
+The key is readability - if your logic fits nicely in one line, list comprehensions are usually the way to go!"""
     }
 ]
 
@@ -100,7 +212,7 @@ SAMPLE_KNOWLEDGE_GRAPHS = [
         "trace_index": 0,  # Links to first trace
         "graph_data": {
             "system_name": "Python Documentation Assistant",
-            "system_summary": "This intelligent assistant processes user inquiries about Python programming through a streamlined workflow. When users submit questions, the knowledgeable agent analyzes them using RAG-powered knowledge search and delivers accurate, contextual responses about Python concepts, syntax, and best practices.",
+            "system_summary": "This intelligent assistant processes user inquiries about Python programming through a comprehensive multi-step workflow. When users submit questions, the agent performs knowledge search, delivers detailed explanations with code examples, and engages in follow-up interactions to ensure thorough understanding of Python concepts, syntax, and performance considerations.",
             "entities": [
                 {
                     "id": "agent_001",
@@ -133,7 +245,7 @@ SAMPLE_KNOWLEDGE_GRAPHS = [
                     "type": "Input",
                     "name": "User Programming Query",
                     "importance": "HIGH",
-                    "raw_prompt": "what are python list comprehensions used for?",
+                    "raw_prompt": "Hello! I'm learning Python and I keep seeing this syntax with square brackets that looks different from regular loops. Can you help me understand what Python list comprehensions are used for and when I should use them?",
                     "raw_prompt_ref": [
                         {
                             "line_start": 19,
@@ -146,7 +258,7 @@ SAMPLE_KNOWLEDGE_GRAPHS = [
                     "type": "Output",
                     "name": "Programming Concept Explanation",
                     "importance": "HIGH",
-                    "raw_prompt": "Python list comprehensions provide an efficient and readable way to create lists by applying expressions to elements in iterables.",
+                    "raw_prompt": "Python list comprehensions are a powerful and concise way to create lists! Here's what they're used for: Main Uses: 1. Creating lists from existing iterables, 2. Filtering data, 3. Mathematical operations, 4. Combining operations. When to use them: For simple transformations, when performance matters, to make code more Pythonic and concise.",
                     "raw_prompt_ref": [
                         {
                             "line_start": 20,
@@ -188,7 +300,7 @@ SAMPLE_KNOWLEDGE_GRAPHS = [
                     "target": "agent_001",
                     "type": "CONSUMED_BY",
                     "importance": "HIGH",
-                    "interaction_prompt": "User query received and processed by the Python documentation agent",
+                    "interaction_prompt": "Extended user inquiry about Python list comprehensions received and processed through multi-step RAG workflow",
                     "interaction_prompt_ref": [
                         {
                             "line_start": 19,
@@ -202,7 +314,7 @@ SAMPLE_KNOWLEDGE_GRAPHS = [
                     "target": "task_001",
                     "type": "PERFORMS",
                     "importance": "HIGH",
-                    "interaction_prompt": "Agent executes programming question processing task",
+                    "interaction_prompt": "Agent executes comprehensive programming question processing including knowledge search, explanation, and code examples",
                     "interaction_prompt_ref": [
                         {
                             "line_start": 26,
@@ -216,7 +328,7 @@ SAMPLE_KNOWLEDGE_GRAPHS = [
                     "target": "output_001",
                     "type": "PRODUCES",
                     "importance": "HIGH",
-                    "interaction_prompt": "Processing task generates comprehensive programming concept explanation",
+                    "interaction_prompt": "Processing task generates detailed multi-part explanation with examples, performance analysis, and interactive follow-ups",
                     "interaction_prompt_ref": [
                         {
                             "line_start": 20,
@@ -230,7 +342,7 @@ SAMPLE_KNOWLEDGE_GRAPHS = [
                     "target": "human_001",
                     "type": "DELIVERS_TO",
                     "importance": "HIGH",
-                    "interaction_prompt": "Programming explanation delivered to requesting developer",
+                    "interaction_prompt": "Comprehensive programming tutorial with examples and performance insights delivered to developer",
                     "interaction_prompt_ref": [
                         {
                             "line_start": 20,
@@ -244,7 +356,7 @@ SAMPLE_KNOWLEDGE_GRAPHS = [
                     "target": "tool_001",
                     "type": "USES",
                     "importance": "HIGH",
-                    "interaction_prompt": "Agent queries knowledge search system to retrieve relevant Python documentation and contextual information",
+                    "interaction_prompt": "Agent performs multi-step knowledge search retrieving documentation, examples, and performance comparisons for comprehensive response",
                     "interaction_prompt_ref": [
                         {
                             "line_start": 49,
@@ -257,8 +369,8 @@ SAMPLE_KNOWLEDGE_GRAPHS = [
                 {
                     "id": "failure_001",
                     "risk_type": "HALLUCINATION",
-                    "description": "Query lacks specificity - could ask about specific Python features rather than general usage.",
-                    "raw_text": "what are python list comprehensions used for?",
+                    "description": "Initial query could benefit from more specific learning objectives, though the multi-turn interaction successfully addressed this through follow-up questions.",
+                    "raw_text": "Hello! I'm learning Python and I keep seeing this syntax with square brackets that looks different from regular loops. Can you help me understand what Python list comprehensions are used for and when I should use them?",
                     "raw_text_ref": [
                         {
                             "line_start": 19,
@@ -272,7 +384,7 @@ SAMPLE_KNOWLEDGE_GRAPHS = [
                 {
                     "id": "opt_001",
                     "recommendation_type": "PROMPT_REFINEMENT",
-                    "description": "Enhance the agent prompt to encourage more specific programming questions and provide structured code examples in responses.",
+                    "description": "Enhance initial query processing to identify learning level and tailor explanations accordingly. The current multi-turn approach works well but could be optimized with upfront user profiling.",
                     "affected_ids": ["agent_001"],
                     "raw_text_ref": [
                         {
@@ -284,7 +396,7 @@ SAMPLE_KNOWLEDGE_GRAPHS = [
                 {
                     "id": "opt_002",
                     "recommendation_type": "TOOL_ENHANCEMENT",
-                    "description": "Expand knowledge search capabilities to include code examples, interactive tutorials, and version-specific documentation alongside basic syntax references.",
+                    "description": "Integrate real-time code execution environment for testing examples, and expand knowledge base to include performance benchmarks and best practice recommendations.",
                     "affected_ids": ["tool_001"],
                     "raw_text_ref": [
                         {
@@ -302,6 +414,8 @@ SAMPLE_KNOWLEDGE_GRAPHS = [
                 "relation_count": 5,
                 "failure_count": 1,
                 "optimization_count": 2,
+                "interaction_depth": "multi_turn",
+                "educational_value": "high",
                 "processing_method": "production_enhanced",
                 "content_source": "documentation_trace",
                 "language": "en",
@@ -314,14 +428,14 @@ SAMPLE_KNOWLEDGE_GRAPHS = [
         "trace_index": 1,  # Links to second trace
         "graph_data": {
             "system_name": "Python Q&A Assistant",
-            "system_summary": "A streamlined question-answering system designed to provide clear information about Python programming concepts. The system processes user questions and delivers comprehensive responses about Python syntax and best practices.",
+            "system_summary": "An interactive educational system designed to provide comprehensive information about Python programming concepts. The system processes user questions and delivers detailed multi-turn responses including step-by-step explanations, code examples, performance analysis, and practical guidance.",
             "entities": [
                 {
                     "id": "user_001",
                     "type": "Human",
                     "name": "User",
                     "importance": "HIGH",
-                    "raw_prompt": "Hello, can you help me understand what Python list comprehensions are used for?",
+                    "raw_prompt": "Hello, can you help me understand what Python list comprehensions are used for? [Extended multi-turn conversation with detailed examples and performance comparisons]",
                     "raw_prompt_ref": [
                         {
                             "line_start": 1,
@@ -360,7 +474,7 @@ SAMPLE_KNOWLEDGE_GRAPHS = [
                     "type": "Output",
                     "name": "Service Overview Response",
                     "importance": "HIGH",
-                    "raw_prompt": "Certainly! Python list comprehensions are a powerful feature that provides: 1. Concise List Creation 2. Efficient Data Filtering 3. Readable Transformations 4. Performance Optimization",
+                    "raw_prompt": "Comprehensive explanation covering list comprehension syntax, use cases, step-by-step breakdowns, performance comparisons with traditional loops, and practical coding examples with benchmarks.",
                     "raw_prompt_ref": [
                         {
                             "line_start": 3,
@@ -432,7 +546,7 @@ SAMPLE_KNOWLEDGE_GRAPHS = [
                 {
                     "id": "opt_simple_001",
                     "recommendation_type": "PROMPT_REFINEMENT",
-                    "description": "Consider adding interactive code examples and hands-on tutorials to allow users to practice the programming concepts being discussed.",
+                    "description": "Add interactive code playground integration and personalized learning paths based on user's demonstrated understanding level throughout the conversation.",
                     "affected_ids": ["assistant_001"],
                     "raw_text_ref": [
                         {
@@ -450,6 +564,8 @@ SAMPLE_KNOWLEDGE_GRAPHS = [
                 "relation_count": 4,
                 "failure_count": 0,
                 "optimization_count": 1,
+                "interaction_depth": "extended",
+                "educational_value": "comprehensive",
                 "processing_method": "simplified_demonstration",
                 "content_source": "conversation_trace",
                 "language": "en",
@@ -560,5 +676,5 @@ def get_sample_data_info():
         "trace_types": list(set(t["trace_type"] for t in SAMPLE_TRACES)),
         "complexity_levels": ["enhanced", "simple"],
         "features": ["rag_search", "failure_detection", "optimization_recommendations", "content_references", "quality_scoring"],
-        "description": "Enhanced AgentGraph examples showcasing Python Documentation RAG-powered assistant with knowledge search, failure detection, optimization suggestions, and advanced knowledge graph features"
+        "description": "Comprehensive AgentGraph examples showcasing Python Documentation RAG-powered assistant with multi-turn interactions, detailed knowledge search, educational content delivery, failure detection, optimization suggestions, and advanced knowledge graph features"
     }