Update art_explorer.py

art_explorer.py

@@ -6,12 +6,10 @@ from prompts import SYSTEM_PROMPT, format_exploration_prompt, DEFAULT_RESPONSE
 
 class ExplorationNode(BaseModel):
   id: Optional[str] = None
-  node_id: Optional[str] = None
-  title: Optional[str] = Field(None, alias='content')
-  description: str = ""
+  title: str
+  description: str
   connections: List[Dict[str, Any]] = Field(default_factory=list)
-  depth: Optional[int] = 0
-  content: Optional[str] = None
+  depth: int = 0
 
 class ExplorationPath(BaseModel):
   nodes: List[ExplorationNode]
@@ -22,6 +20,80 @@ class ExplorationPath(BaseModel):
       populate_by_name = True
       arbitrary_types_allowed = True
 
+def transform_response_to_nodes(api_response: Dict[str, Any]) -> List[Dict[str, Any]]:
+  """Transform the API response into a list of ExplorationNode-compatible dictionaries"""
+  nodes = []
+  
+  # Add main exploration summary as root node
+  if "exploration_summary" in api_response:
+      nodes.append({
+          "id": "root",
+          "title": "Exploration Overview",
+          "description": api_response["exploration_summary"]["current_context"],
+          "depth": 0,
+          "connections": []
+      })
+
+  # Transform standard axes into nodes
+  if "knowledge_axes" in api_response and "standard_axes" in api_response["knowledge_axes"]:
+      for axis in api_response["knowledge_axes"]["standard_axes"]:
+          # Create node for the axis itself
+          axis_node = {
+              "id": f"axis_{axis['name']}",
+              "title": axis['name'],
+              "description": f"Standard exploration axis: {axis['name']}",
+              "depth": 1,
+              "connections": []
+          }
+          nodes.append(axis_node)
+          
+          # Create nodes for potential values
+          for idx, value in enumerate(axis.get("potential_values", [])):
+              value_node = {
+                  "id": f"value_{axis['name']}_{idx}",
+                  "title": value["value"],
+                  "description": value["contextual_rationale"],
+                  "depth": 2,
+                  "connections": []
+              }
+              nodes.append(value_node)
+              # Add connection to axis node
+              axis_node["connections"].append({
+                  "target_id": value_node["id"],
+                  "relevance_score": value["relevance_score"]
+              })
+
+  # Transform emergent axes into nodes
+  if "knowledge_axes" in api_response and "emergent_axes" in api_response["knowledge_axes"]:
+      for e_axis in api_response["knowledge_axes"]["emergent_axes"]:
+          # Create node for emergent axis
+          e_axis_node = {
+              "id": f"emergent_{e_axis['name']}",
+              "title": f"{e_axis['name']} (Emergent)",
+              "description": f"Emergent axis derived from {e_axis['parent_axis']}",
+              "depth": 2,
+              "connections": []
+          }
+          nodes.append(e_axis_node)
+          
+          # Create nodes for innovative values
+          for idx, value in enumerate(e_axis.get("innovative_values", [])):
+              value_node = {
+                  "id": f"innovative_{e_axis['name']}_{idx}",
+                  "title": value["value"],
+                  "description": value["discovery_potential"],
+                  "depth": 3,
+                  "connections": []
+              }
+              nodes.append(value_node)
+              # Add connection to emergent axis node
+              e_axis_node["connections"].append({
+                  "target_id": value_node["id"],
+                  "innovation_score": value["innovation_score"]
+              })
+
+  return nodes
+
 class ExplorationPathGenerator:
   def __init__(self, api_key: str):
       self.client = OpenAI(
@@ -41,7 +113,6 @@ class ExplorationPathGenerator:
           selected_path = selected_path or []
           exploration_parameters = exploration_parameters or {}
           
-          # Format the exploration prompt using the helper function
           formatted_prompt = format_exploration_prompt(
               user_query=query,
               selected_path=selected_path,
@@ -49,25 +120,15 @@ class ExplorationPathGenerator:
           )
           
           print("\n=== Formatted Request ===")
-          print("System Prompt:", SYSTEM_PROMPT)  # First 200 chars
-          print("\nFormatted Prompt (excerpt):", formatted_prompt)
+          print("System Prompt:", SYSTEM_PROMPT[:200] + "...")
+          print("\nFormatted Prompt (excerpt):", formatted_prompt[:200] + "...")
           
-          messages = [
-              {"role": "system", "content": SYSTEM_PROMPT},
-              {"role": "user", "content": formatted_prompt}
-          ]
-          
-          print("\n=== API Request Parameters ===")
-          print(json.dumps({
-              "model": "mixtral-8x7b-32768",
-              "messages": [{"role": m["role"], "content": m["content"]} for m in messages],
-              "temperature": 0.7,
-              "max_tokens": 2000
-          }, indent=2))
-
           response = self.client.chat.completions.create(
               model="mixtral-8x7b-32768",
-              messages=messages,
+              messages=[
+                  {"role": "system", "content": SYSTEM_PROMPT},
+                  {"role": "user", "content": formatted_prompt}
+              ],
               temperature=0.7,
               max_tokens=2000
           )
@@ -75,28 +136,35 @@ class ExplorationPathGenerator:
           print("\n=== API Response ===")
           print("Raw response content:", response.choices[0].message.content)
 
-          # Parse the response
           try:
               result = json.loads(response.choices[0].message.content)
               print("\n=== Parsed Response ===")
               print(json.dumps(result, indent=2))
+              
+              # Transform the API response into nodes
+              nodes = transform_response_to_nodes(result)
+              
+              # Create ExplorationPath with transformed nodes
+              exploration_path = ExplorationPath(
+                  nodes=nodes,
+                  query=query,
+                  domain=exploration_parameters.get("domain")
+              )
+              
+              final_result = exploration_path.model_dump()
+              print("\n=== Final Result ===")
+              print(json.dumps(final_result, indent=2))
+              
+              return final_result
+              
           except json.JSONDecodeError as e:
               print(f"\n=== JSON Parse Error ===\n{str(e)}")
               print("Using default response")
-              result = DEFAULT_RESPONSE
-
-          # Convert to ExplorationPath model
-          exploration_path = ExplorationPath(
-              nodes=result.get("nodes", []),  # Changed from list comprehension to simple get
-              query=query,
-              domain=exploration_parameters.get("domain")
-          )
-          
-          final_result = exploration_path.model_dump()
-          print("\n=== Final Result ===")
-          print(json.dumps(final_result, indent=2))
-          
-          return final_result
+              return {
+                  "nodes": [],
+                  "query": query,
+                  "domain": exploration_parameters.get("domain")
+              }
 
       except Exception as e:
           print(f"\n=== Error ===\n{str(e)}")