為你的 App 加入 AI 功能:程式碼優先指南

# pip install openai
import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

def ask_ai(user_message: str) -> str:
    """Call the LLM and return the response text."""
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": "You are a helpful assistant for our SaaS product."},
            {"role": "user", "content": user_message},
        ],
        temperature=0.7,
        max_tokens=1024,
    )
    return response.choices[0].message.content

// npm install openai
import OpenAI from "openai";

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

async function askAI(userMessage: string): Promise<string> {
  const response = await client.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [
      { role: "system", content: "You are a helpful assistant for our SaaS product." },
      { role: "user", content: userMessage },
    ],
    temperature: 0.7,
    max_tokens: 1024,
  });
  return response.choices[0].message.content ?? "";
}

# pip install fastapi openai sse-starlette
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from openai import OpenAI
import os

app = FastAPI()
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

@app.post("/api/chat")
async def chat(user_message: str):
    """Stream the LLM response token by token."""
    def generate():
        stream = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": "You are a helpful SaaS assistant."},
                {"role": "user", "content": user_message},
            ],
            stream=True,
        )
        for chunk in stream:
            if chunk.choices[0].delta.content:
                yield chunk.choices[0].delta.content

    return StreamingResponse(generate(), media_type="text/event-stream")

// npm install ai openai
// app/api/chat/route.ts (Next.js App Router)
import { openai } from "@ai-sdk/openai";
import { streamText } from "ai";

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

  const result = streamText({
    model: openai("gpt-4o-mini"),
    system: "You are a helpful SaaS assistant.",
    messages,
  });

  return result.toDataStreamResponse();
}

// components/Chat.tsx
"use client";
import { useChat } from "@ai-sdk/react";

export default function Chat() {
  const { messages, input, handleInputChange, handleSubmit, isLoading } = useChat({
    api: "/api/chat",
  });

  return (
    <div>
      {messages.map((m) => (
        <div key={m.id} className={m.role === "user" ? "user-msg" : "ai-msg"}>
          {m.content}
        </div>
      ))}
      <form onSubmit={handleSubmit}>
        <input value={input} onChange={handleInputChange} placeholder="Ask something..." />
        <button type="submit" disabled={isLoading}>Send</button>
      </form>
    </div>
  );
}

from pydantic import BaseModel
from openai import OpenAI

client = OpenAI()

class ProductReview(BaseModel):
    sentiment: str  # "positive", "negative", "neutral"
    key_points: list[str]
    rating: int  # 1-5
    recommended: bool

response = client.beta.chat.completions.parse(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "Extract a structured review from user text."},
        {"role": "user", "content": "Amazing product! Fast shipping, great quality. Only downside is the price."},
    ],
    response_format=ProductReview,
)

review = response.choices[0].message.parsed
print(review.sentiment)    # "positive"
print(review.rating)       # 4
print(review.key_points)   # ["Fast shipping", "Great quality", "High price"]

import OpenAI from "openai";

const client = new OpenAI();

const response = await client.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [{ role: "user", content: "Update my email to [email protected]" }],
  tools: [
    {
      type: "function",
      function: {
        name: "update_user_profile",
        description: "Updates a field on the user's profile",
        parameters: {
          type: "object",
          properties: {
            field: { type: "string", enum: ["email", "name", "avatar_url"] },
            value: { type: "string" },
          },
          required: ["field", "value"],
        },
      },
    },
  ],
});

// The model returns a tool_call -- you execute it in your backend
const toolCall = response.choices[0].message.tool_calls?.[0];
if (toolCall?.function.name === "update_user_profile") {
  const args = JSON.parse(toolCall.function.arguments);
  await db.users.update({ [args.field]: args.value }); // Your DB call
}

# pip install openai numpy psycopg2-binary pgvector
from openai import OpenAI
import numpy as np

client = OpenAI()
# 步驟 1：嵌入文件區塊
def embed(text: str) -> list[float]:
    response = client.embeddings.create(model="text-embedding-3-small", input=text)
    return response.data[0].embedding
# 步驟 2：儲存至 pgvector（假設已存在具有向量欄位的資料表）
def store_chunk(cursor, text: str, embedding: list[float]):
    cursor.execute(
        "INSERT INTO documents (content, embedding) VALUES (%s, %s)",
        (text, np.array(embedding).tolist()),
    )
# 步驟三：擷取相關區塊
def search(cursor, query: str, top_k: int = 3) -> list[str]:
    query_embedding = embed(query)
    cursor.execute(
        """SELECT content FROM documents
           ORDER BY embedding <=> %s::vector LIMIT %s""",
        (np.array(query_embedding).tolist(), top_k),
    )
    return [row[0] for row in cursor.fetchall()]
# 步驟 4：附帶上下文向 LLM 提問
def ask_with_context(question: str, cursor) -> str:
    chunks = search(cursor, question)
    context = "\n\n".join(chunks)
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": f"Answer using this context:\n\n{context}"},
            {"role": "user", "content": question},
        ],
    )
    return response.choices[0].message.content

import OpenAI from "openai";
import Anthropic from "@anthropic-ai/sdk";

const openai = new OpenAI();
const anthropic = new Anthropic();

async function aiWithFallback(prompt: string): Promise<string> {
  const models = [
    () => callOpenAI("gpt-4o-mini", prompt),
    () => callOpenAI("gpt-4o", prompt),
    () => callAnthropic("claude-3-5-haiku-latest", prompt),
  ];

  for (const callModel of models) {
    try {
      return await withRetry(callModel, { maxRetries: 2, baseDelay: 1000 });
    } catch (err) {
      console.warn(`Model failed, trying next fallback...`, err);
    }
  }
  // All models failed -- return cached or static response
  return "I'm temporarily unable to process your request. Please try again shortly.";
}

async function withRetry<T>(fn: () => Promise<T>, opts: { maxRetries: number; baseDelay: number }): Promise<T> {
  for (let i = 0; i <= opts.maxRetries; i++) {
    try {
      return await fn();
    } catch (err: any) {
      if (i === opts.maxRetries) throw err;
      if (err?.status === 429 || err?.status >= 500) {
        await new Promise((r) => setTimeout(r, opts.baseDelay * 2 ** i)); // Exponential backoff
      } else {
        throw err; // Don't retry client errors (400, 401, etc.)
      }
    }
  }
  throw new Error("Unreachable");
}