OpenAI Integration

pip install openai requests

import os
import requests
from openai import OpenAI

# Configuration
FATHIPPO_API_KEY = os.environ.get("FATHIPPO_API_KEY", "mem_your_key")
FATHIPPO_URL = "https://fathippo.ai/api/v1"

client = OpenAI()

def get_context(user_message: str) -> str:
    """Get relevant context from FatHippo"""
    response = requests.post(
        f"{FATHIPPO_URL}/simple/context",
        headers={"Authorization": f"Bearer {FATHIPPO_API_KEY}"},
        json={"message": user_message}
    )
    return response.json().get("context", "")

def chat(user_message: str) -> str:
    """Chat with memory-augmented GPT"""
    context = get_context(user_message)
    
    messages = [
        {
            "role": "system",
            "content": f"""You are a helpful assistant with memory of past conversations.

{context}

Use the context above to personalize your responses. Reference previous 
conversations when relevant."""
        },
        {"role": "user", "content": user_message}
    ]
    
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages
    )
    
    return response.choices[0].message.content

# Example
print(chat("Schedule a meeting for next week"))
# "Based on your preference for morning meetings and your Singapore timezone..."

import requests
from openai import OpenAI
from typing import Optional

FATHIPPO_API_KEY = "mem_your_key"
FATHIPPO_URL = "https://fathippo.ai/api/v1"

client = OpenAI()

class MemoryAgent:
    def __init__(self):
        self.session_id: Optional[str] = None
        self.turn_count = 0
        self.context = ""
        self.memories_used: list[str] = []
    
    def start_session(self, first_message: str):
        """Start a new session and get initial context"""
        response = requests.post(
            f"{FATHIPPO_URL}/sessions/start",
            headers={"Authorization": f"Bearer {FATHIPPO_API_KEY}"},
            json={"firstMessage": first_message}
        ).json()
        
        self.session_id = response["sessionId"]
        self.turn_count = 0
        
        # Build context from critical + high memories
        context_parts = []
        
        if response["context"]["critical"]:
            context_parts.append("## Core Context")
            for mem in response["context"]["critical"]:
                context_parts.append(f"- {mem['text']}")
                self.memories_used.append(mem["id"])
        
        if response["context"]["high"]:
            context_parts.append("\n## Relevant Context")
            for mem in response["context"]["high"]:
                context_parts.append(f"- {mem['text']}")
                self.memories_used.append(mem["id"])
        
        self.context = "\n".join(context_parts)
        
        print(f"Session started: {self.session_id}")
        print(f"Tokens injected: {response['stats']['tokensInjected']}")
    
    def chat(self, user_message: str) -> str:
        """Send a message and get response"""
        if not self.session_id:
            self.start_session(user_message)
        
        self.turn_count += 1
        
        messages = [
            {
                "role": "system",
                "content": f"You are a helpful assistant.\n\n{self.context}"
            },
            {"role": "user", "content": user_message}
        ]
        
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages
        )
        
        assistant_message = response.choices[0].message.content
        
        # Record the turn
        turn_response = requests.post(
            f"{FATHIPPO_URL}/sessions/{self.session_id}/turn",
            headers={"Authorization": f"Bearer {FATHIPPO_API_KEY}"},
            json={
                "turnNumber": self.turn_count,
                "messages": [
                    {"role": "user", "content": user_message},
                    {"role": "assistant", "content": assistant_message}
                ],
                "memoriesUsed": self.memories_used
            }
        ).json()
        
        # Refresh context if needed
        if turn_response.get("refreshNeeded") and "newContext" in turn_response:
            self._update_context(turn_response["newContext"])
        
        return assistant_message
    
    def _update_context(self, new_context: dict):
        """Update context with fresh memories"""
        context_parts = [self.context]
        
        if new_context.get("high"):
            context_parts.append("\n## Updated Context")
            for mem in new_context["high"]:
                context_parts.append(f"- {mem['text']}")
                if mem["id"] not in self.memories_used:
                    self.memories_used.append(mem["id"])
        
        self.context = "\n".join(context_parts)
    
    def remember(self, text: str):
        """Store a new memory"""
        requests.post(
            f"{FATHIPPO_URL}/simple/remember",
            headers={"Authorization": f"Bearer {FATHIPPO_API_KEY}"},
            json={"text": text}
        )
    
    def end_session(self, outcome: str = "success"):
        """End the session"""
        if self.session_id:
            requests.post(
                f"{FATHIPPO_URL}/sessions/{self.session_id}/end",
                headers={"Authorization": f"Bearer {FATHIPPO_API_KEY}"},
                json={"outcome": outcome}
            )
            self.session_id = None

# Usage
agent = MemoryAgent()
print(agent.chat("Help me plan my week"))
agent.remember("User prefers to front-load meetings on Monday")
print(agent.chat("What should I do on Friday?"))
agent.end_session()

def extract_and_store(conversation: list[dict]):
    """Extract memories from conversation and store them"""
    response = requests.post(
        f"{FATHIPPO_URL}/extract",
        headers={"Authorization": f"Bearer {FATHIPPO_API_KEY}"},
        json={"conversation": conversation}
    ).json()
    
    # Store high-confidence suggestions
    for suggestion in response["suggestions"]:
        if suggestion["confidence"] >= 0.8:
            requests.post(
                f"{FATHIPPO_URL}/memories",
                headers={"Authorization": f"Bearer {FATHIPPO_API_KEY}"},
                json={
                    "content": suggestion["content"],
                    "memoryType": suggestion["memoryType"],
                    "importanceTier": suggestion["suggestedTier"]
                }
            )
            print(f"Stored: {suggestion['title']}")

# After conversation ends
extract_and_store([
    {"role": "user", "content": "My name is John and I prefer morning meetings"},
    {"role": "assistant", "content": "Nice to meet you, John!"}
])