AI Agent Architecture: Production Design

// Single agent with tool calling — TypeScript
import OpenAI from 'openai'

const openai = new OpenAI()

const tools: OpenAI.Chat.Completions.ChatCompletionTool[] = [
  {
    type: 'function',
    function: {
      name: 'search_crm',
      description: 'Search CRM for company information',
      parameters: {
        type: 'object',
        properties: {
          company_name: { type: 'string' },
        },
        required: ['company_name'],
      },
    },
  },
  {
    type: 'function',
    function: {
      name: 'update_lead_score',
      description: 'Update lead score in CRM',
      parameters: {
        type: 'object',
        properties: {
          lead_id: { type: 'string' },
          score: { type: 'number', minimum: 0, maximum: 100 },
          reason: { type: 'string' },
        },
        required: ['lead_id', 'score', 'reason'],
      },
    },
  },
]

async function runAgent(userMessage: string, maxIterations = 10) {
  const messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = [
    { role: 'system', content: SYSTEM_PROMPT },
    { role: 'user', content: userMessage },
  ]

  for (let i = 0; i < maxIterations; i++) {
    const response = await openai.chat.completions.create({
      model: 'gpt-4o',
      messages,
      tools,
    })

    const message = response.choices[0].message
    messages.push(message)

    if (message.finish_reason === 'stop') {
      return message.content // Task complete
    }

    if (message.tool_calls) {
      for (const toolCall of message.tool_calls) {
        const result = await executeTool(toolCall) // your tool executor
        messages.push({
          role: 'tool',
          tool_call_id: toolCall.id,
          content: JSON.stringify(result),
        })
      }
    }
  }

  throw new Error('Max iterations reached — task incomplete')
}

// Multi-agent orchestration pattern
type AgentTask = {
  agent: 'research' | 'writer' | 'verifier'
  input: string
  context?: Record<string, unknown>
}

async function orchestrator(goal: string) {
  // Orchestrator decomposes the goal into tasks
  const plan = await planTasks(goal) // calls GPT-4o

  const results: Record<string, string> = {}

  for (const task of plan.tasks) {
    switch (task.agent) {
      case 'research':
        // Research agent has: web_search, scrape_url, database_query
        results.research = await researchAgent(task.input)
        break
      case 'writer':
        // Writer agent has: draft_document, format_output
        results.draft = await writerAgent(task.input, results.research)
        break
      case 'verifier':
        // Verifier agent has: fact_check, score_quality
        results.verified = await verifierAgent(results.draft)
        break
    }
  }

  return results
}

// Memory-augmented agent with vector recall
import { prisma } from '@/lib/prisma'
import OpenAI from 'openai'

const openai = new OpenAI()

async function getRelevantContext(query: string): Promise<string[]> {
  // Generate embedding for the query
  const embedding = await openai.embeddings.create({
    model: 'text-embedding-3-small',
    input: query,
  })

  // Retrieve top-5 semantically similar documents
  const docs = await prisma.$queryRaw<{ content: string; score: number }[]>`
    SELECT content,
           1 - (embedding <=> ${JSON.stringify(embedding.data[0].embedding)}::vector) AS score
    FROM knowledge_base
    WHERE 1 - (embedding <=> ${JSON.stringify(embedding.data[0].embedding)}::vector) > 0.75
    ORDER BY score DESC
    LIMIT 5
  `

  return docs.map(d => d.content)
}

async function memoryAgent(userQuery: string) {
  // Retrieve context before calling the LLM
  const context = await getRelevantContext(userQuery)

  const response = await openai.chat.completions.create({
    model: 'gpt-4o',
    messages: [
      {
        role: 'system',
        content: `Answer based ONLY on the provided context.
If the answer is not in the context, say so clearly.

CONTEXT:
${context.join('\n\n---\n\n')}`,
      },
      { role: 'user', content: userQuery },
    ],
  })

  return response.choices[0].message.content
}