AI Coach

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=...
DATABASE_URL=postgres://...

# .env.local
SYNAP_API_KEY=...
OPENAI_API_KEY=...
DATABASE_URL=postgres://...

SESSIONS: dict[str, str] = {}

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

const SESSIONS = new Map<string, string>();
function convFor(userId: string): string {
  if (!SESSIONS.has(userId)) SESSIONS.set(userId, crypto.randomUUID());
  return SESSIONS.get(userId)!;
}

from agents import function_tool

@function_tool
async def set_goal(user_id: str, goal: str, target_date: str) -> dict:
    """Set or update the user's primary training goal."""
    return await db.goals.upsert(user_id, goal, target_date)

@function_tool
async def get_current_plan(user_id: str) -> dict:
    """Return the user's current week plan with session list and status."""
    return await db.plans.current(user_id)

@function_tool
async def log_session(user_id: str, kind: str, payload: dict) -> dict:
    """Log a completed session. kind: 'run' | 'lift' | 'sleep' | 'meal' | 'mood'."""
    return await db.sessions.create(user_id, kind, payload)

@function_tool
async def get_streak(user_id: str, kind: str) -> dict:
    """Return current and best streak for a session kind."""
    return await db.sessions.streak(user_id, kind)

@function_tool
async def suggest_plan_adjustment(user_id: str, reason: str) -> dict:
    """Generate a tentative plan adjustment, save it as pending for user approval."""
    return await planner.adjust(user_id, reason)

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

const coachTools = {
  set_goal: tool({
    description: "Set or update the user's primary training goal.",
    parameters: z.object({
      userId: z.string(), goal: z.string(), targetDate: z.string(),
    }),
    execute: async ({ userId, goal, targetDate }) => db.goals.upsert(userId, goal, targetDate),
  }),
  get_current_plan: tool({
    description: "Return the user's current week plan with session list and status.",
    parameters: z.object({ userId: z.string() }),
    execute: async ({ userId }) => db.plans.current(userId),
  }),
  log_session: tool({
    description: "Log a completed session.",
    parameters: z.object({
      userId: z.string(),
      kind: z.enum(["run", "lift", "sleep", "meal", "mood"]),
      payload: z.record(z.any()),
    }),
    execute: async ({ userId, kind, payload }) => db.sessions.create(userId, kind, payload),
  }),
  get_streak: tool({
    description: "Return current and best streak for a session kind.",
    parameters: z.object({ userId: z.string(), kind: z.string() }),
    execute: async ({ userId, kind }) => db.sessions.streak(userId, kind),
  }),
  suggest_plan_adjustment: tool({
    description: "Generate a tentative plan adjustment for user approval.",
    parameters: z.object({ userId: z.string(), reason: z.string() }),
    execute: async ({ userId, reason }) => planner.adjust(userId, reason),
  }),
};

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()

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

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

    agent = Agent(
        name="coach",
        instructions=SYSTEM,
        tools=[
            FunctionTool(synap_search, name_override="synap_search"),
            FunctionTool(synap_store,  name_override="synap_store"),
            set_goal, get_current_plan, log_session, get_streak, suggest_plan_adjustment,
        ],
    )

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

    asyncio.create_task(sdk.memories.create(
        document=f"User: {text}\nCoach: {reply}",
        document_type="ai-chat-conversation",
        user_id=user_id,
        customer_id="coach",
        metadata={"conversation_id": conv_id},
    ))
    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! });

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

  const model = synap.wrap(openai("gpt-4o"), {
    userId,
    customerId: "coach",
    conversationId,
  });

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

  return reply;
}