Uber: Customer Support

pip install maximem-synap maximem-synap-openai-agents openai-agents

uv add maximem-synap maximem-synap-openai-agents openai-agents
# pip-compatible (existing venv): uv pip install maximem-synap maximem-synap-openai-agents openai-agents

npm install @maximem/synap-js-sdk @maximem/synap-vercel-adk ai @ai-sdk/openai zod

# .env
SYNAP_API_KEY=...
OPENAI_API_KEY=...

# .env.local
SYNAP_API_KEY=...
OPENAI_API_KEY=...

# session_id → conversation_id mapping. Use Redis in production.
SESSIONS: dict[str, str] = {}

def conv_for(session_id: str) -> str:
    return SESSIONS.setdefault(session_id, str(uuid.uuid4()))

// session_id → conversation_id mapping. Use Redis in production.
const SESSIONS = new Map<string, string>();

function convFor(sessionId: string): string {
  if (!SESSIONS.has(sessionId)) SESSIONS.set(sessionId, crypto.randomUUID());
  return SESSIONS.get(sessionId)!;
}

from agents import function_tool

@function_tool
async def get_recent_rides(rider_id: str, limit: int = 5) -> list[dict]:
    """Return the rider's most recent rides."""
    return await rides_api.recent(rider_id, limit)

@function_tool
async def request_refund(ride_id: str, reason: str) -> dict:
    """Initiate a refund for a specific ride. Returns refund_id and ETA."""
    return await refunds_api.create(ride_id, reason)

@function_tool
async def create_lost_item_report(rider_id: str, ride_id: str, description: str) -> dict:
    """Open a lost-item report tied to a specific ride."""
    return await lost_items_api.create(rider_id, ride_id, description)

@function_tool
async def escalate_to_human(rider_id: str, summary: str) -> dict:
    """Open a Tier-2 ticket and hand off the conversation."""
    return await tickets_api.open(rider_id, summary, tier=2)

import { tool } from "ai";
import { z } from "zod";

const businessTools = {
  get_recent_rides: tool({
    description: "Return the rider's most recent rides.",
    parameters: z.object({ riderId: z.string(), limit: z.number().default(5) }),
    execute: async ({ riderId, limit }) => ridesApi.recent(riderId, limit),
  }),
  request_refund: tool({
    description: "Initiate a refund for a specific ride. Returns refund_id and ETA.",
    parameters: z.object({ rideId: z.string(), reason: z.string() }),
    execute: async ({ rideId, reason }) => refundsApi.create(rideId, reason),
  }),
  create_lost_item_report: tool({
    description: "Open a lost-item report tied to a specific ride.",
    parameters: z.object({
      riderId: z.string(),
      rideId: z.string(),
      description: z.string(),
    }),
    execute: async ({ riderId, rideId, description }) =>
      lostItemsApi.create(riderId, rideId, description),
  }),
  escalate_to_human: tool({
    description: "Open a Tier-2 ticket and hand off the conversation.",
    parameters: z.object({ riderId: z.string(), summary: z.string() }),
    execute: async ({ riderId, summary }) => ticketsApi.open(riderId, summary, 2),
  }),
};

import os, uuid, asyncio
from agents import Agent, FunctionTool, Runner
from maximem_synap import MaximemSynapSDK
from synap_openai_agents import create_search_tool, create_store_tool

sdk = MaximemSynapSDK()
await sdk.initialize()

SYSTEM = """You are an Uber rider support agent.

- Always check the rider's recent rides before suggesting actions.
- Use prior resolutions and the rider's communication preferences from memory.
- Escalate to a human if: the rider explicitly asks, the issue involves safety, or the disputed amount exceeds $50.
- Keep replies under 4 sentences. Be warm and outcome-focused."""

async def handle_message(rider_id: str, session_id: str, text: str) -> str:
    conv_id = conv_for(session_id)

    synap_search = create_search_tool(sdk=sdk, user_id=rider_id, customer_id="uber")
    synap_store  = create_store_tool(sdk=sdk, user_id=rider_id, customer_id="uber")

    agent = Agent(
        name="uber_rider_support",
        instructions=SYSTEM,
        tools=[
            FunctionTool(synap_search, name_override="synap_search"),
            FunctionTool(synap_store,  name_override="synap_store"),
            get_recent_rides,
            request_refund,
            create_lost_item_report,
            escalate_to_human,
        ],
    )

    result = await Runner.run(agent, input=text)
    reply = result.final_output

    # Persist the full turn so the next message has context.
    # Fire-and-forget; never blocks the response.
    asyncio.create_task(sdk.memories.create(
        document=f"Rider: {text}\nAgent: {reply}",
        document_type="ai-chat-conversation",
        user_id=rider_id,
        customer_id="uber",
        metadata={"conversation_id": conv_id, "channel": "in-app-chat"},
    ))
    return reply

import { generateText } from "ai";
import { openai } from "@ai-sdk/openai";
import { createSynap } from "@maximem/synap-vercel-adk";

const synap = await createSynap({ apiKey: process.env.SYNAP_API_KEY! });

const SYSTEM = `You are an Uber rider support agent.

- Always check the rider's recent rides before suggesting actions.
- Use prior resolutions and the rider's communication preferences from memory.
- Escalate to a human if: the rider explicitly asks, the issue involves safety, or the disputed amount exceeds $50.
- Keep replies under 4 sentences. Be warm and outcome-focused.`;

export async function handleMessage(
  riderId: string,
  sessionId: string,
  text: string,
): Promise<string> {
  const conversationId = convFor(sessionId);

  // synap.wrap injects rider context as a system message before the LLM call
  // and ingests the completed turn afterward. No manual fetch / ingest needed.
  const model = synap.wrap(openai("gpt-4o"), {
    userId: riderId,
    customerId: "uber",
    conversationId,
  });

  const { text: reply } = await generateText({
    model,
    system: SYSTEM,
    prompt: text,
    tools: businessTools,
  });

  return reply;
}

docs = await sdk.memories.list(
    user_id="rider_42",
    customer_id="uber",
    limit=20,
)
for d in docs:
    print(d.document_type, ":", d.content[:120])

const docs = await synap.sdk.memories.list({
  userId: "rider_42",
  customerId: "uber",
  limit: 20,
});
for (const d of docs) {
  console.log(d.documentType, ":", d.content.slice(0, 120));
}