mem.attribution(
    entity_id="project_alpha",     # What entity is the agent working on behalf of?
    process_id="research_agent"    # What agent is this?
)

from memori import Memori
from openai import OpenAI
from typing import List, Dict

class TaskAgent:
    def __init__(self, user_id: str):
        self.client = OpenAI()
        self.mem = Memori().llm.register(self.client)
        self.mem.attribution(
            entity_id=user_id,
            process_id="task_planner"
        )
    
    def plan_tasks(self, goal: str) -> str:
        """Break down a goal into actionable tasks."""
        response = self.client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {
                    "role": "system",
                    "content": "You are a task planning agent. Break goals into clear, "
                               "actionable tasks. Learn from past task completions."
                },
                {"role": "user", "content": f"Plan tasks for: {goal}"}
            ]
        )
        return response.choices[0].message.content
    
    def report_completion(self, task: str, outcome: str):
        """Report a completed task and its outcome."""
        response = self.client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {
                    "role": "user",
                    "content": f"Task completed: {task}\nOutcome: {outcome}"
                }
            ]
        )
        return response.choices[0].message.content

# Usage
agent = TaskAgent("developer_123")

# Week 1: Plan feature development
plan = agent.plan_tasks(
    "Build a user authentication system with email and OAuth"
)
print(plan)

# Report progress
agent.report_completion(
    "Set up OAuth integration",
    "Implemented Google and GitHub OAuth. Took 4 hours, worked smoothly."
)

agent.mem.augmentation.wait()

# Week 2: Plan similar task — agent learns from experience
plan2 = agent.plan_tasks(
    "Add Microsoft OAuth support to authentication system"
)
print(plan2)
# Agent recalls: Previous OAuth integration, time estimates, successful patterns

from memori import Memori
from openai import OpenAI

class WorkflowAgent:
    def __init__(self, project_id: str, agent_name: str):
        self.client = OpenAI()
        self.mem = Memori().llm.register(self.client)
        self.mem.attribution(
            entity_id=project_id,
            process_id=agent_name
        )
    
    def execute_step(self, step_description: str) -> str:
        """Execute a workflow step."""
        response = self.client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {
                    "role": "system",
                    "content": "You are a workflow agent. Execute steps in sequence, "
                               "referencing previous steps as needed."
                },
                {"role": "user", "content": step_description}
            ]
        )
        return response.choices[0].message.content

# Usage
agent = WorkflowAgent("project_beta", "deployment_agent")

# Step 1: Prepare deployment
print("Step 1: Prepare")
result1 = agent.execute_step(
    "Prepare deployment checklist for production release. "
    "Environment: AWS ECS, Database: PostgreSQL RDS."
)
print(result1)

# Step 2: Verify configuration
print("\nStep 2: Verify")
result2 = agent.execute_step(
    "Verify all configuration settings are correct for deployment."
)
print(result2)
# Agent recalls: AWS ECS, PostgreSQL RDS from Step 1

# Step 3: Execute deployment
print("\nStep 3: Deploy")
result3 = agent.execute_step(
    "Execute deployment based on the prepared checklist and verified configuration."
)
print(result3)
# Agent references Steps 1 and 2

agent.mem.augmentation.wait()

from memori import Memori
from openai import OpenAI

client = OpenAI()
mem = Memori().llm.register(client)
mem.attribution(
    entity_id="project_gamma",
    process_id="data_analyst"
)

# Session 1: Analyze Q1 data
print("=== Q1 Analysis ===")
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{
        "role": "user",
        "content": "Analyze Q1 sales data. Revenue: $1.2M, Growth: 15%"
    }]
)
print(response.choices[0].message.content)

# Start new session for Q2
mem.new_session()

print("\n=== Q2 Analysis ===")
response2 = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{
        "role": "user",
        "content": "Analyze Q2 sales data. Revenue: $1.5M, Growth: 25%"
    }]
)
print(response2.choices[0].message.content)
# Memori maintains separate session contexts while sharing entity-level facts

import asyncio
from memori import Memori
from openai import AsyncOpenAI

class AsyncAgent:
    def __init__(self, entity_id: str, process_id: str):
        self.client = AsyncOpenAI()
        self.mem = Memori().llm.register(self.client)
        self.mem.attribution(
            entity_id=entity_id,
            process_id=process_id
        )
    
    async def execute(self, task: str) -> str:
        response = await self.client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": "You are an AI agent."},
                {"role": "user", "content": task}
            ]
        )
        return response.choices[0].message.content

async def main():
    agent = AsyncAgent("user_123", "async_agent")
    result = await agent.execute("Analyze this data...")
    print(result)

asyncio.run(main())