Morphik Agent

# User asks: "Analyze sales trends and predict next quarter"
# Agent autonomously:
# 1. Lists sales documents
# 2. Retrieves sales data chunks  
# 3. Analyzes trends using document_analyzer
# 4. Executes Python code for predictions
# 5. Saves insights to memory
# 6. Generates comprehensive report

result = db.agent_query(
    "Analyze our sales trends over the last year and predict "
    "performance for next quarter. Save key insights for future reference."
)

# Agent can automatically write code like this:
"""
import pandas as pd
import matplotlib.pyplot as plt

# Parse sales data from retrieved chunks
sales_data = [...]  # Data from document chunks
df = pd.DataFrame(sales_data)

# Calculate growth rate
growth_rate = (df['Q4'] - df['Q1']) / df['Q1'] * 100

# Create visualization
plt.plot(df['quarter'], df['sales'])
plt.title('Sales Trends')
plt.savefig('sales_trends.png')

print(f"Growth rate: {growth_rate:.2f}%")
"""

result = db.agent_query(
    "How are our enterprise customers connected to our premium products? "
    "Show me the relationship paths and identify expansion opportunities."
)

# Agent might:
# 1. List available graphs
# 2. Query for enterprise customer entities
# 3. Find paths to premium products
# 4. Analyze relationship strengths
# 5. Generate expansion strategy

# First interaction
result1 = db.agent_query("Analyze customer churn patterns and save findings")

# Later interaction - agent remembers previous analysis
result2 = db.agent_query("Based on our churn analysis, what retention strategies should we implement?")

[
  {
    "tool_name": "list_documents",
    "tool_args": {"filters": {"department": "sales"}},
    "tool_result": "Found 15 sales documents..."
  },
  {
    "tool_name": "execute_code", 
    "tool_args": {"code": "growth_rate = (Q4 - Q1) / Q1 * 100"},
    "tool_result": "Growth rate: 23.5%"
  }
]

[
  {
    "type": "text",
    "content": "## Sales Analysis\nGrowth rate increased by 23.5%...",
    "source": "doc123-chunk1"
  },
  {
    "type": "image",
    "content": "<base64_image_data>",
    "caption": "Sales trend chart showing quarterly growth",
    "source": "doc456-chart2"
  }
]

[
  {
    "sourceId": "doc123-chunk1",
    "documentName": "Q3 Sales Report",
    "documentId": "123",
    "content": "Sales increased significantly..."
  }
]

# Good: Clear outcome desired
"Analyze customer satisfaction scores, identify trends, and recommend improvements"

# Less optimal: Vague request  
"Tell me about customers"

# Good: Provides direction
"Calculate quarterly revenue growth and compare to industry benchmarks"

# Less optimal: Missing context
"Show me revenue numbers"

result = db.agent_query("Complex analysis request")

# Understand what the agent did
for tool in result["tool_history"]:
    print(f"Used {tool['tool_name']} with {tool['tool_args']}")

for obj in result["display_objects"]:
    if obj["type"] == "image":
        # Display image in UI with caption
        display_image(obj["content"], caption=obj["caption"])
    elif obj["type"] == "text":
        # Render markdown content
        render_markdown(obj["content"])

def safe_agent_query(query):
    try:
        result = db.agent_query(query)
        
        # Check for errors in response
        if "error" in result.get("response", "").lower():
            return {"error": "Agent encountered an error", "details": result["response"]}
            
        # Check if any tools failed
        failed_tools = [
            tool for tool in result.get("tool_history", [])
            if "error" in str(tool.get("tool_result", "")).lower()
        ]
        
        if failed_tools:
            return {"error": "Some tools failed", "failed_tools": failed_tools}
            
        return result
        
    except Exception as e:
        return {"error": "Agent query failed", "exception": str(e)}

# Use memory for cumulative analysis
queries = [
    "Analyze customer segments and save key characteristics",
    "Based on customer segments, identify high-value opportunities", 
    "Create action plan for the top 3 opportunities identified"
]

for query in queries:
    result = db.agent_query(query)
    print(f"Query: {query}")
    print(f"Response: {result['response']}\n")