OpenAI Integration Guide

// app/actions/ai.ts
'use server'
import OpenAI from 'openai'

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
})

export async function generateSummary(text: string): Promise<string> {
  const response = await openai.chat.completions.create({
    model: 'gpt-4o',
    max_tokens: 500,
    messages: [
      {
        role: 'system',
        content: 'You are a precise summariser. Return a 3-sentence summary.',
      },
      {
        role: 'user',
        content: text,
      },
    ],
  })

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

// app/api/chat/route.ts
import { openai } from '@ai-sdk/openai'
import { streamText } from 'ai'

export async function POST(req: Request) {
  const { messages } = await req.json()

  const result = await streamText({
    model: openai('gpt-4o'),
    system: 'You are a helpful SaaS assistant.',
    messages,
    maxTokens: 1000,
  })

  return result.toDataStreamResponse()
}

// components/Chat.tsx (client component)
'use client'
import { useChat } from 'ai/react'

export function Chat() {
  const { messages, input, handleInputChange, handleSubmit, isLoading } = useChat()

  return (
    <div>
      {messages.map(m => (
        <div key={m.id}>{m.role}: {m.content}</div>
      ))}
      <form onSubmit={handleSubmit}>
        <input value={input} onChange={handleInputChange} />
        <button type="submit" disabled={isLoading}>Send</button>
      </form>
    </div>
  )
}

// Structured extraction with tool use
const response = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [
    { role: 'user', content: 'Extract the key details from: John Smith, john@acme.com, wants pricing for 50 seats, timeline: Q3 2026' }
  ],
  tools: [
    {
      type: 'function',
      function: {
        name: 'extract_lead',
        description: 'Extract structured lead information from the message',
        parameters: {
          type: 'object',
          properties: {
            name: { type: 'string' },
            email: { type: 'string' },
            seats: { type: 'number' },
            timeline: { type: 'string' },
          },
          required: ['name', 'email'],
        },
      },
    },
  ],
  tool_choice: 'required',
})

const toolCall = response.choices[0].message.tool_calls?.[0]
const lead = JSON.parse(toolCall?.function.arguments ?? '{}')
// { name: 'John Smith', email: 'john@acme.com', seats: 50, timeline: 'Q3 2026' }

// 1. Generate embedding for a document chunk
async function embedText(text: string): Promise<number[]> {
  const response = await openai.embeddings.create({
    model: 'text-embedding-3-small',
    input: text,
  })
  return response.data[0].embedding
}

// 2. Store in PostgreSQL with pgvector
await prisma.$executeRaw`
  INSERT INTO documents (content, embedding)
  VALUES (${chunk}, ${JSON.stringify(embedding)}::vector)
`

// 3. At query time — find semantically similar chunks
async function retrieveContext(query: string): Promise<string[]> {
  const queryEmbedding = await embedText(query)

  const results = await prisma.$queryRaw<{ content: string }[]>`
    SELECT content
    FROM documents
    ORDER BY embedding <=> ${JSON.stringify(queryEmbedding)}::vector
    LIMIT 5
  `
  return results.map(r => r.content)
}

// 4. Include retrieved context in the GPT-4o prompt
const context = await retrieveContext(userQuery)
const answer = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [
    { role: 'system', content: `Answer based only on this context: ${context.join('\n')}` },
    { role: 'user', content: userQuery },
  ],
})