AMP
GitHub
Guides

Integration Examples

Real-world examples of integrating AMP into different frameworks.

Next.js App Router

app/api/agent/route.ts
import { AMP } from '@amp-protocol/client';
import OpenAI from 'openai';

const amp = new AMP({ apiKey: process.env.AMP_API_KEY });
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

export async function POST(request: Request) {
  const { userId, query } = await request.json();

  // Get motivation context
  const context = await amp.getContext({
    userId,
    task: query
  });

  // Adapt system prompt
  const systemPrompt = `You are a helpful assistant.
Communication: ${context.communicationStyle}
Framing: ${context.suggestedFraming}
Detail level: ${context.complexity}`;

  // Generate response
  const completion = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [
      { role: 'system', content: systemPrompt },
      { role: 'user', content: query }
    ]
  });

  // Report outcome (fire and forget)
  amp.reportOutcome({
    requestId: context.requestId,
    started: true,
    completed: true
  }).catch(console.error);

  return Response.json({
    response: completion.choices[0].message.content
  });
}

Express.js

server.ts
import express from 'express';
import { AMP } from '@amp-protocol/client';

const app = express();
const amp = new AMP({ apiKey: process.env.AMP_API_KEY });

app.post('/api/agent', async (req, res) => {
  const { userId, query } = req.body;

  const context = await amp.getContext({ userId, task: query });

  // Use context to adapt response
  const response = await generateResponse(query, context);

  res.json({ response });

  // Report outcome in background
  trackUserBehaviour(userId, context.requestId);
});

Python FastAPI

main.py
from fastapi import FastAPI
from amp_protocol import AMP
import os

app = FastAPI()
amp = AMP(api_key=os.getenv("AMP_API_KEY"))

@app.post("/api/agent")
async def handle_query(request: dict):
    user_id = request["userId"]
    query = request["query"]

    # Get context
    context = await amp.get_context(
        user_id=user_id,
        task=query
    )

    # Adapt response based on context
    response = await generate_response(query, context)

    # Report outcome
    await amp.report_outcome(
        request_id=context.request_id,
        started=True,
        completed=True
    )

    return {"response": response}

LangChain Integration

from langchain.agents import Agent
from amp_protocol import AMP

amp = AMP(api_key=os.getenv("AMP_API_KEY"))

class AMPAgent(Agent):
    def run(self, user_id: str, task: str):
        # Get AMP context
        context = amp.get_context(user_id=user_id, task=task)

        # Adapt agent behaviour
        if context.complexity == "break_into_steps":
            return self.run_step_by_step(task)
        else:
            return self.run_direct(task)

See Also