Workflows for organizing interactions into requests and sessions, querying by time range, and cleaning up data.

Managing Requests & Sessions

Workflows for organizing interactions into requests and sessions, querying by time range, and cleaning up data. For method-level details, see the Requests API Reference.

Setup

from reflexio import ReflexioClient

client = ReflexioClient()  # uses REFLEXIO_API_KEY env var
# Self-hosted: client = ReflexioClient(url_endpoint="http://localhost:8081")

Basic Request Publishing

Publishing a Request

# Publish a request (generates profiles and playbook entries)
response = client.publish_interaction(
    user_id="user_123",
    interactions=[
        {"role": "User", "content": "What's the weather like?"},
        {"role": "Agent", "content": "I'll check the weather for you."}
    ],
    source="web_app",
    agent_version="v1.0.0",
    wait_for_response=True
)

print(f"Success: {response.success}")

Publishing with Session

# Group related requests together
client.publish_interaction(
    user_id="user_123",
    interactions=[...],
    session_id="onboarding_session_001",
    source="mobile_app",
    agent_version="v1.0.0"
)

Retrieving Requests

Get All Requests in a Session

# Retrieve all requests for a user
response = client.get_requests(user_id="user_456")

# Iterate through sessions
for session in response.sessions:
    print(f"\nSession: {session.session_id}")

    # Each session contains multiple requests
    for request_data in session.requests:
        request = request_data.request
        interactions = request_data.interactions

        print(f"  Request ID: {request.request_id}")
        print(f"  Agent Version: {request.agent_version}")
        print(f"  Source: {request.source}")
        print(f"  Interaction Count: {len(interactions)}")

        # Access individual interactions
        for interaction in interactions:
            print(f"    - {interaction.role}: {interaction.content[:50]}...")

Filter Requests by User

# Get all requests for a specific user with limit
response = client.get_requests(
    user_id="user_123",
    top_k=50
)

# Count requests per session
for session in response.sessions:
    print(f"Session: {session.session_id}")
    print(f"  Requests: {len(session.requests)}")

# Filter by time range
from datetime import datetime, timedelta

response = client.get_requests(
    user_id="user_123",
    start_time=datetime.now() - timedelta(days=7),
    end_time=datetime.now()
)

Deleting Requests

Delete a Single Request

# Delete a specific request and all its interactions
response = client.delete_request(
    request_id="req_12345",
    wait_for_response=True
)

if response.success:
    print(f"Deleted: {response.message}")

Delete an Entire Session

# Delete all requests in a session (useful for cleanup)
response = client.delete_session(
    session_id="session_001",
    wait_for_response=True
)

if response.success:
    print(f"Deleted {response.deleted_requests_count} requests")
    print(f"Message: {response.message}")

Fire-and-Forget Deletion

# Non-blocking deletion (doesn't wait for response)
client.delete_session(
    session_id="old_session",
    wait_for_response=False
)
# Continues immediately without waiting

Advanced Patterns

Session-Based Organization

import uuid

# Create a unique session ID
session_id = str(uuid.uuid4())

# Track all requests in a session (using dict format)
interactions_in_session = [
    [{"role": "User", "content": "First question"}],
    [{"role": "User", "content": "Follow-up question"}],
    [{"role": "User", "content": "Final question"}]
]

for interaction_batch in interactions_in_session:
    client.publish_interaction(
        user_id="user_123",
        interactions=interaction_batch,
        session_id=f"session_{session_id}",
        source="chat_interface"
    )

# Later: retrieve entire session
session_data = client.get_requests(user_id="user_123")

Cleaning Up Old Sessions

# List of completed sessions to clean up
completed_sessions = [
    "session_2024_01",
    "session_2024_02",
    "test_run_abc"
]

# Delete all at once
for session_id in completed_sessions:
    response = client.delete_session(
        session_id=session_id,
        wait_for_response=True
    )
    if response.success:
        print(f"Cleaned up {session_id}: {response.deleted_count} requests deleted")

Common Patterns

Pattern 1: Session with Cleanup

session_id = "temp_session_123"

try:
    # Run session
    client.publish_interaction(
        user_id="user_test",
        interactions=[...],
        session_id=session_id
    )

    # Retrieve results
    results = client.get_requests(user_id="user_test")

    # Process results...

finally:
    # Always clean up
    client.delete_session(
        session_id=session_id,
        wait_for_response=True
    )

Pattern 2: Versioned Sessions

from datetime import datetime

# Create versioned session name
session_version = f"session_{datetime.now().strftime('%Y%m%d')}"

# Publish with version tracking
client.publish_interaction(
    user_id="user_123",
    interactions=[...],
    session_id=session_version,
    agent_version="v1.0"
)

Managing Requests & Sessions

On this page