pip install pixeltable

import pixeltable as pxt
from datetime import datetime
from typing import List, Dict

# Initialize app structure
pxt.drop_dir("chatbot", force=True)
pxt.create_dir("chatbot")

# Create memory table
memory = pxt.create_table(
    path_str="chatbot.memory",
    {
        "role": pxt.String,
        "content": pxt.String,
        "timestamp": pxt.Timestamp,
    },
    if_exists="ignore",
)

# Create chat session table
chat_session = pxt.create_table(
    path_str="chatbot.chat_session",
    {"user_message": pxt.String, "timestamp": pxt.Timestamp},
    if_exists="ignore",
)

# Define memory retrieval
@pxt.query
def get_recent_memory():
    return (
        memory.order_by(memory.timestamp, asc=False)
        .select(role=memory.role, content=memory.content)
        .limit(10)
    )

# Define message creation
@pxt.udf
def create_messages(past_context: List[Dict], current_message: str) -> List[Dict]:
    messages = [
        {
            "role": "system",
            "content": "You are a chatbot with memory capabilities.",
        }
    ]
    messages.extend(
        [{"role": msg["role"], "content": msg["content"]} for msg in past_context]
    )
    messages.append({"role": "user", "content": current_message})
    return messages

# Configure processing workflow
chat_session.add_computed_column(memory_context=get_recent_memory())
chat_session.add_computed_column(
    prompt=create_messages(chat_session.memory_context, chat_session.user_message)
)
chat_session.add_computed_column(
    llm_response=pxt.functions.openai.chat_completions(
        messages=chat_session.prompt,
        model="gpt-4o-mini"
    )
)
chat_session.add_computed_column(
    assistant_response=chat_session.llm_response.choices[0].message.content
)

import pixeltable as pxt
from datetime import datetime

# Connect to your app
memory = pxt.get_table("chatbot.memory")
chat_session = pxt.get_table("chatbot.chat_session")

def chat(message: str) -> str:
    """Process a message through the memory-enabled chatbot"""
    # Store user message
    memory.insert([{
        "role": "user",
        "content": message,
        "timestamp": datetime.now()
    }])

    # Process through chat session
    chat_session.insert([{
        "user_message": message,
        "timestamp": datetime.now()
    }])

    # Get response
    result = chat_session.select(
        chat_session.assistant_response
    ).where(
        chat_session.user_message == message
    ).collect()
    
    response = result["assistant_response"][0]

    # Store assistant response
    memory.insert([{
        "role": "assistant",
        "content": response,
        "timestamp": datetime.now()
    }])

    return response

# Use it!
responses = [
    chat("Hi! My name is Alice."),
    chat("What's the weather like today?"),
    chat("Can you remember my name?"),
]

# Print responses
for i, response in enumerate(responses, 1):
    print(f"\nExchange {i}:")
    print(f"Bot: {response}")