Ship and run your product. Skip the platform team.

const messages = pgTable(
  'messages',
  {
    id: text('id').primaryKey(),
    authorName: text('author_name').notNull(),
    authorKind: text('author_kind').notNull(),
    body: text('body').notNull(),
    createdAt: timestamp('created_at', { withTimezone: true }).notNull(),
  },
  (t) => [index('messages_created_at').on(t.createdAt)],
);

export const MessageStore = Postgres.create({ schema: { messages } });

export const AgentSettings = Settings.create(z.object({
  apiKey: z.string(),
  model: z.string(),
  systemPrompt: z.string().default(DEFAULT_SYSTEM_PROMPT),
}));

export const AgentContract = Service.contract('agent', {
  methods: {
    respond: {
      input: z.object({
        prompt: MessageSchema,
        history: z.array(MessageSchema),
      }),
      output: z.string(),
    },
  },
});

export const AgentService = Service.implement(
  AgentContract,
  {
    requires: {
      db: MessageStore,
      other: OtherContract,
      settings: AgentSettings,
    },
    mcp: [{ handler: 'respond', tool: 'agent_respond' }],
  },
  ({ db, other, settings }) => ({
    respond: async ({ history, prompt }) => {
      const agent = createAgent(settings);
      await Promise.all([
        db.insert(MessageStore.messages).values(toMessage(prompt)),
        other.doSomething(),
      ]);
      // ... your special sauce
      return '';
    },
  }),
);

# messages.sql holds the table and its index.
message_store = Psycopg.create(
    schema=Path(__file__).parent / "messages.sql",
)


class AgentSettings(BaseModel):
    api_key: str
    model: str
    system_prompt: str = DEFAULT_SYSTEM_PROMPT


agent_settings = Settings.create(AgentSettings)


class Respond(BaseModel):
    prompt: Message
    history: list[Message]


agent_contract = Service.contract(
    "agent",
    version="1.0.0",
    methods={"respond": Method(input=Respond, output=str)},
)


@Service.implement(
    agent_contract,
    requires={
        "db": message_store,
        "other": other_contract,
        "settings": agent_settings,
    },
    expose={"mcp": [McpExpose(tool="agent_respond", handler="respond")]},
)
def agent_service(bindings, errors):
    db: Psycopg.Pool = bindings.db
    settings: AgentSettings = bindings.settings

    async def respond(request: Respond) -> str:
        agent = create_agent(settings)
        async with db.connection() as conn:
            await asyncio.gather(
                conn.execute(INSERT_MESSAGE, to_row(request.prompt)),
                bindings.other.do_something(),
            )
        # ... your special sauce
        return ""

    return {"respond": respond}