// AI Agent handles account creation conversationally
const createAccountAgent = async (userMessage: string) => {
  const result = await streamText({
    model: openai("gpt-4"),
    tools: {
      validateEmail: tool({
        description: "Validate email format and availability",
        parameters: z.object({ email: z.string() }),
        execute: async ({ email }) => {
          // Check email validity and availability
        },
      }),
      createAccount: tool({
        description: "Create new user account",
        parameters: z.object({
          email: z.string(),
          name: z.string(),
          preferences: z.object({}),
        }),
        execute: async (data) => {
          // Create account in database
        },
      }),
    },
  });
};

const productSearchAgent = {
  searchProducts: tool({
    description: "Search products using natural language",
    parameters: z.object({
      query: z.string(),
      preferences: z.object({
        priceRange: z.string().optional(),
        style: z.string().optional(),
      }),
    }),
    execute: async ({ query, preferences }) => {
      // Use vector embeddings for semantic search
      const embedding = await embed(query);
      const products = await vectorSearch(embedding, preferences);
      return products;
    },
  }),
};

const supportAgent = {
  answerQuery: tool({
    description: "Answer customer support questions",
    parameters: z.object({
      question: z.string(),
      orderId: z.string().optional(),
      userId: z.string(),
    }),
    execute: async ({ question, orderId, userId }) => {
      // RAG system searches knowledge base + order history
      const context = await retrieveContext(question, userId);
      const answer = await generateAnswer(question, context);
      return answer;
    },
  }),
  escalateToHuman: tool({
    description: "Escalate complex issues to human support",
    execute: async ({ issue }) => {
      // Create support ticket
    },
  }),
};

const contentGenerator = tool({
  description: "Generate product content",
  parameters: z.object({
    productData: z.object({
      name: z.string(),
      features: z.array(z.string()),
      category: z.string(),
    }),
  }),
  execute: async ({ productData }) => {
    const content = await generateText({
      model: openai("gpt-4"),
      prompt: `Generate compelling product description, SEO title, 
               meta description, and bullet points for: ${JSON.stringify(productData)}`,
    });
    return content;
  },
});

const inventoryAgent = {
  predictDemand: tool({
    description: "Predict product demand",
    parameters: z.object({
      productId: z.string(),
      timeframe: z.string(),
    }),
    execute: async ({ productId, timeframe }) => {
      const historicalData = await getHistoricalSales(productId);
      const trends = await analyzeTrends(historicalData);
      const prediction = await aiModel.predict({
        data: historicalData,
        trends,
        seasonality: true,
        externalFactors: ["weather", "events"],
      });
      return prediction;
    },
  }),
  autoReorder: tool({
    description: "Automatically create purchase orders",
    execute: async ({ predictions }) => {
      // Generate optimal reorder quantities
    },
  }),
};

const emailMarketingAgent = {
  generatePersonalizedEmail: tool({
    description: "Create personalized marketing email",
    parameters: z.object({
      userId: z.string(),
      campaignType: z.string(),
    }),
    execute: async ({ userId, campaignType }) => {
      const userData = await getUserProfile(userId);
      const browsingHistory = await getBrowsingHistory(userId);
      const purchaseHistory = await getPurchaseHistory(userId);
 
      const email = await generateText({
        model: openai("gpt-4"),
        prompt: `Create personalized email for user who:
                 - Interests: ${userData.interests}
                 - Recently viewed: ${browsingHistory}
                 - Past purchases: ${purchaseHistory}
                 Campaign: ${campaignType}`,
      });
 
      return email;
    },
  }),
  optimizeSendTime: tool({
    description: "Predict optimal send time",
    execute: async ({ userId }) => {
      // Analyze user engagement patterns
    },
  }),
};

const documentProcessor = {
  extractData: tool({
    description: "Extract structured data from documents",
    parameters: z.object({
      documentUrl: z.string(),
      documentType: z.string(),
    }),
    execute: async ({ documentUrl, documentType }) => {
      const document = await fetchDocument(documentUrl);
 
      const extraction = await generateObject({
        model: openai("gpt-4-vision"),
        schema: z.object({
          invoiceNumber: z.string(),
          date: z.string(),
          vendor: z.string(),
          items: z.array(
            z.object({
              description: z.string(),
              quantity: z.number(),
              price: z.number(),
            })
          ),
          total: z.number(),
        }),
        prompt: `Extract all relevant data from this ${documentType}`,
      });
 
      return extraction;
    },
  }),
  validateData: tool({
    description: "Validate extracted data",
    execute: async ({ data }) => {
      // Cross-reference and validate
    },
  }),
};

const formAssistant = {
  predictFields: tool({
    description: "Predict and auto-fill form fields",
    parameters: z.object({
      formType: z.string(),
      userContext: z.object({}),
    }),
    execute: async ({ formType, userContext }) => {
      // Use previous submissions + profile data
      const predictions = await generateObject({
        model: openai("gpt-4"),
        schema: formSchema,
        prompt: `Based on user profile and previous forms, suggest values for ${formType}`,
      });
      return predictions;
    },
  }),
  validateInRealTime: tool({
    description: "Validate fields as user types",
    execute: async ({ field, value }) => {
      // Intelligent validation with helpful suggestions
    },
  }),
};

const codeReviewAgent = {
  analyzePR: tool({
    description: "Analyze pull request for issues",
    parameters: z.object({
      prNumber: z.string(),
      files: z.array(z.string()),
    }),
    execute: async ({ prNumber, files }) => {
      const analysis = await generateText({
        model: openai("gpt-4"),
        prompt: `Review this code for:
                 - Security vulnerabilities
                 - Performance issues
                 - Best practice violations
                 - Potential bugs
                 - Code style consistency
                 Files: ${files.join(", ")}`,
      });
      return analysis;
    },
  }),
  suggestFixes: tool({
    description: "Generate code fix suggestions",
    execute: async ({ issue }) => {
      // Generate corrected code snippets
    },
  }),
};

const sentimentAgent = {
  analyzeReview: tool({
    description: "Analyze customer review sentiment",
    parameters: z.object({
      reviewText: z.string(),
      productId: z.string(),
    }),
    execute: async ({ reviewText, productId }) => {
      const analysis = await generateObject({
        model: openai("gpt-4"),
        schema: z.object({
          sentimentScore: z.number(),
          emotions: z.array(z.string()),
          topics: z.array(z.string()),
          urgency: z.enum(["low", "medium", "high", "critical"]),
          suggestedResponse: z.string(),
        }),
        prompt: `Analyze this product review: "${reviewText}"`,
      });
 
      if (analysis.urgency === "critical") {
        await alertCustomerService(productId, analysis);
      }
 
      return analysis;
    },
  }),
  identifyTrends: tool({
    description: "Identify trending issues across reviews",
    execute: async ({ productId, timeframe }) => {
      // Aggregate sentiment data and identify patterns
    },
  }),
};

const meetingAgent = {
  transcribeAndSummarize: tool({
    description: "Transcribe and summarize meeting",
    parameters: z.object({
      audioUrl: z.string(),
      meetingType: z.string(),
    }),
    execute: async ({ audioUrl, meetingType }) => {
      const transcription = await transcribeAudio(audioUrl);
 
      const summary = await generateObject({
        model: openai("gpt-4"),
        schema: z.object({
          keyPoints: z.array(z.string()),
          actionItems: z.array(
            z.object({
              task: z.string(),
              assignee: z.string(),
              deadline: z.string(),
            })
          ),
          decisions: z.array(z.string()),
          followUpNeeded: z.array(z.string()),
        }),
        prompt: `Summarize this ${meetingType} meeting transcription`,
      });
 
      return summary;
    },
  }),
  extractActionItems: tool({
    description: "Extract and assign action items",
    execute: async ({ summary }) => {
      // Create tasks in project management system
    },
  }),
};

const pricingAgent = {
  optimizePrice: tool({
    description: "Calculate optimal price",
    parameters: z.object({
      productId: z.string(),
      timestamp: z.string(),
    }),
    execute: async ({ productId, timestamp }) => {
      const factors = await gatherPricingFactors({
        demandLevel: await getCurrentDemand(productId),
        competitorPrices: await getCompetitorPrices(productId),
        inventory: await getInventoryLevel(productId),
        historicalSales: await getSalesHistory(productId),
        seasonality: await getSeasonalFactors(timestamp),
        userSegment: await getCurrentUserSegment(),
      });
 
      const optimalPrice = await generateObject({
        model: openai("gpt-4"),
        schema: z.object({
          price: z.number(),
          confidence: z.number(),
          reasoning: z.string(),
        }),
        prompt: `Calculate optimal price considering: ${JSON.stringify(factors)}`,
      });
 
      return optimalPrice;
    },
  }),
};

const onboardingAgent = {
  guideEmployee: tool({
    description: "Guide new employee through onboarding",
    parameters: z.object({
      employeeId: z.string(),
      stage: z.string(),
    }),
    execute: async ({ employeeId, stage }) => {
      const employeeData = await getEmployeeData(employeeId);
      const requirements = await getOnboardingRequirements(stage);
 
      const guidance = await streamText({
        model: openai("gpt-4"),
        tools: {
          completeTask: tool({
            description: "Mark onboarding task as complete",
            execute: async ({ taskId }) => {
              // Update onboarding progress
            },
          }),
          scheduleOrientation: tool({
            description: "Schedule orientation sessions",
            execute: async ({ sessions }) => {
              // Book calendar slots
            },
          }),
          answerPolicyQuestion: tool({
            description: "Answer questions about company policies",
            execute: async ({ question }) => {
              // RAG system searches policy documents
            },
          }),
        },
      });
 
      return guidance;
    },
  }),
};

const qualityControlAgent = {
  inspectProduct: tool({
    description: "Inspect product for defects",
    parameters: z.object({
      imageUrl: z.string(),
      productType: z.string(),
    }),
    execute: async ({ imageUrl, productType }) => {
      const inspection = await generateObject({
        model: openai("gpt-4-vision"),
        schema: z.object({
          defectsFound: z.array(
            z.object({
              type: z.string(),
              severity: z.enum(["minor", "major", "critical"]),
              location: z.string(),
              confidence: z.number(),
            })
          ),
          overallQuality: z.enum(["pass", "fail"]),
          reasoning: z.string(),
        }),
        messages: [
          {
            role: "user",
            content: [
              { type: "text", text: `Inspect this ${productType} for defects` },
              { type: "image", image: imageUrl },
            ],
          },
        ],
      });
 
      return inspection;
    },
  }),
};

const recommendationAgent = {
  generateRecommendations: tool({
    description: "Generate personalized product recommendations",
    parameters: z.object({
      userId: z.string(),
      context: z.object({
        currentPage: z.string(),
        sessionHistory: z.array(z.string()),
      }),
    }),
    execute: async ({ userId, context }) => {
      const userProfile = await getUserProfile(userId);
      const behaviorPatterns = await analyzeBehavior(userId);
      const similarUsers = await findSimilarUsers(userId);
      const trendingProducts = await getTrendingProducts();
 
      const recommendations = await generateObject({
        model: openai("gpt-4"),
        schema: z.object({
          products: z.array(
            z.object({
              productId: z.string(),
              relevanceScore: z.number(),
              reasoning: z.string(),
            })
          ),
        }),
        prompt: `Generate recommendations considering:
                 - User preferences: ${JSON.stringify(userProfile)}
                 - Behavior: ${JSON.stringify(behaviorPatterns)}
                 - Similar users bought: ${JSON.stringify(similarUsers)}
                 - Current context: ${JSON.stringify(context)}`,
      });
 
      return recommendations;
    },
  }),
};

const legalAgent = {
  reviewContract: tool({
    description: "Analyze legal document for risks",
    parameters: z.object({
      documentUrl: z.string(),
      contractType: z.string(),
    }),
    execute: async ({ documentUrl, contractType }) => {
      const document = await fetchDocument(documentUrl);
 
      const analysis = await generateObject({
        model: openai("gpt-4"),
        schema: z.object({
          riskLevel: z.enum(["low", "medium", "high", "critical"]),
          issues: z.array(
            z.object({
              clause: z.string(),
              risk: z.string(),
              severity: z.string(),
              recommendation: z.string(),
            })
          ),
          missingClauses: z.array(z.string()),
          summary: z.string(),
          requiresLawyerReview: z.boolean(),
        }),
        prompt: `Analyze this ${contractType} contract for legal risks and issues`,
      });
 
      return analysis;
    },
  }),
};

const voiceOrderingAgent = {
  processVoiceOrder: tool({
    description: "Process voice-based order",
    parameters: z.object({
      audioInput: z.string(),
      userId: z.string(),
    }),
    execute: async ({ audioInput, userId }) => {
      const transcription = await transcribeAudio(audioInput);
 
      const orderProcessing = await streamText({
        model: openai("gpt-4"),
        tools: {
          searchProducts: tool({
            description: "Search for products mentioned",
            execute: async ({ query }) => {
              return await searchProductsCatalog(query);
            },
          }),
          confirmOrder: tool({
            description: "Confirm order details",
            execute: async ({ products, deliveryAddress }) => {
              return await createOrder(userId, products, deliveryAddress);
            },
          }),
          processPayment: tool({
            description: "Process payment",
            execute: async ({ paymentMethodId, amount }) => {
              return await chargePayment(paymentMethodId, amount);
            },
          }),
        },
        messages: [
          {
            role: "user",
            content: transcription,
          },
        ],
      });
 
      return orderProcessing;
    },
  }),
};

# Install Vercel AI SDK
npm install ai @ai-sdk/openai @ai-sdk/anthropic
 
# Install React dependencies
npm install @vercel/ai react
 
# For Next.js App Router
npm install ai next

# OpenAI
OPENAI_API_KEY=your_openai_key
 
# Anthropic (Claude)
ANTHROPIC_API_KEY=your_anthropic_key
 
# Optional: For custom models
CUSTOM_MODEL_API_KEY=your_key

// lib/ai-config.ts
import { createOpenAI } from "@ai-sdk/openai";
import { createAnthropic } from "@ai-sdk/anthropic";
 
export const openai = createOpenAI({
  apiKey: process.env.OPENAI_API_KEY,
  compatibility: "strict", // or 'compatible'
});
 
export const anthropic = createAnthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});
 
// Default model configurations
export const defaultChatModel = openai("gpt-4-turbo");
export const defaultEmbeddingModel = openai.embedding("text-embedding-3-small");

import { generateText, generateObject, streamText } from "ai";
import { openai } from "@ai-sdk/openai";
import { z } from "zod";
 
// Generate text
const { text } = await generateText({
  model: openai("gpt-4-turbo"),
  prompt: "Explain quantum computing",
});
 
// Generate structured output
const { object } = await generateObject({
  model: openai("gpt-4-turbo"),
  schema: z.object({
    name: z.string(),
    age: z.number(),
    email: z.string().email(),
  }),
  prompt: "Generate a user profile",
});
 
// Stream responses
const result = await streamText({
  model: openai("gpt-4-turbo"),
  prompt: "Write a long story",
});
 
for await (const chunk of result.textStream) {
  process.stdout.write(chunk);
}

'use client';
import { useChat, useCompletion } from 'ai/react';
 
export function ChatComponent() {
  const { messages, input, handleInputChange, handleSubmit, isLoading } = useChat({
    api: '/api/chat',
    initialMessages: [],
  });
 
  return (
    <div>
      {messages.map(m => (
        <div key={m.id} className={m.role}>
          {m.content}
        </div>
      ))}
 
      <form onSubmit={handleSubmit}>
        <input
          value={input}
          onChange={handleInputChange}
          disabled={isLoading}
          placeholder="Type your message..."
        />
        <button type="submit" disabled={isLoading}>
          Send
        </button>
      </form>
    </div>
  );
}

import { ChatWindow, MessageList, InputBar } from '@vercel/ai-elements';
 
export function AdvancedChat() {
  return (
    <ChatWindow
      theme="dark"
      position="bottom-right"
      // Pre-configured with best practices
      features={{
        streaming: true,
        markdown: true,
        codeHighlight: true,
        fileUpload: true,
      }}
    >
      <MessageList
        showTimestamps
        showAvatars
        enableMarkdown
      />
      <InputBar
        placeholder="Ask me anything..."
        suggestions={[
          "How can I help you today?",
          "Tell me about your products",
        ]}
      />
    </ChatWindow>
  );
}

// next.config.js
module.exports = {
  experimental: {
    aiGateway: {
      enabled: true,
      // Caching configuration
      cache: {
        enabled: true,
        ttl: 3600, // 1 hour
      },
      // Rate limiting
      rateLimit: {
        requests: 100,
        window: "1m",
      },
      // Cost tracking
      analytics: {
        enabled: true,
        logRequests: true,
      },
      // Model routing
      routing: {
        default: "openai/gpt-4-turbo",
        fallback: "anthropic/claude-3-sonnet",
      },
    },
  },
};

import { gatewayFetch } from "@vercel/ai-gateway";
 
// Automatically cached based on prompt + parameters
const response = await gatewayFetch({
  model: "gpt-4-turbo",
  prompt: "Explain AI",
  cache: {
    strategy: "semantic", // semantic or exact
    ttl: 3600,
  },
});

// Track and limit AI spending
const response = await gatewayFetch({
  model: "gpt-4-turbo",
  prompt: "Generate content",
  budget: {
    maxCost: 0.5, // USD
    onExceed: "fallback", // or 'reject'
    fallbackModel: "gpt-3.5-turbo",
  },
});

// Per-user rate limiting
export async function POST(req: Request) {
  const userId = await getUserId(req);
 
  const response = await gatewayFetch({
    model: "gpt-4-turbo",
    prompt: await req.text(),
    rateLimit: {
      key: userId,
      limit: 10,
      window: "1m",
    },
  });
 
  return Response.json(response);
}

// Automatic fallback on errors
const response = await gatewayFetch({
  model: "gpt-4-turbo",
  prompt: "Complex query",
  fallback: ["gpt-4", "claude-3-opus", "gpt-3.5-turbo"],
  retries: 3,
});

// View in Vercel Dashboard:
// - Request volume
// - Cost per endpoint
// - Average latency
// - Cache hit rate
// - Error rates
// - Model usage breakdown

# Create Next.js project
npx create-next-app@latest ecommerce-ai-bot
cd ecommerce-ai-bot
 
# Install dependencies
npm install ai @ai-sdk/openai zod
npm install prisma @prisma/client
npm install stripe
npm install bcrypt jsonwebtoken

// prisma/schema.prisma
generator client {
  provider = "prisma-client-js"
}
 
datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}
 
model User {
  id        String   @id @default(cuid())
  email     String   @unique
  name      String
  password  String
  createdAt DateTime @default(now())
  orders    Order[]
  cart      CartItem[]
}
 
model Product {
  id          String   @id @default(cuid())
  name        String
  description String
  price       Float
  category    String
  stock       Int
  imageUrl    String
  cartItems   CartItem[]
  orderItems  OrderItem[]
}
 
model CartItem {
  id        String  @id @default(cuid())
  userId    String
  productId String
  quantity  Int
  user      User    @relation(fields: [userId], references: [id])
  product   Product @relation(fields: [productId], references: [id])
}
 
model Order {
  id         String      @id @default(cuid())
  userId     String
  total      Float
  status     String
  createdAt  DateTime    @default(now())
  user       User        @relation(fields: [userId], references: [id])
  items      OrderItem[]
}
 
model OrderItem {
  id        String  @id @default(cuid())
  orderId   String
  productId String
  quantity  Int
  price     Float
  order     Order   @relation(fields: [orderId], references: [id])
  product   Product @relation(fields: [productId], references: [id])
}

// lib/agents/ecommerce-tools.ts
import { tool } from "ai";
import { z } from "zod";
import { prisma } from "@/lib/prisma";
import bcrypt from "bcrypt";
import jwt from "jsonwebtoken";
 
export const ecommerceTools = {
  // User Management
  createAccount: tool({
    description: "Create a new user account",
    parameters: z.object({
      email: z.string().email(),
      name: z.string(),
      password: z.string().min(8),
    }),
    execute: async ({ email, name, password }) => {
      try {
        // Check if user exists
        const existing = await prisma.user.findUnique({
          where: { email },
        });
 
        if (existing) {
          return {
            success: false,
            message: "Email already registered",
          };
        }
 
        // Hash password
        const hashedPassword = await bcrypt.hash(password, 10);
 
        // Create user
        const user = await prisma.user.create({
          data: {
            email,
            name,
            password: hashedPassword,
          },
        });
 
        // Generate JWT token
        const token = jwt.sign({ userId: user.id }, process.env.JWT_SECRET!, {
          expiresIn: "7d",
        });
 
        return {
          success: true,
          message: `Account created successfully! Welcome, ${name}!`,
          userId: user.id,
          token,
        };
      } catch (error) {
        return {
          success: false,
          message: "Failed to create account",
          error: error.message,
        };
      }
    },
  }),
 
  // Product Search
  searchProducts: tool({
    description: "Search for products by name, category, or description",
    parameters: z.object({
      query: z.string(),
      category: z.string().optional(),
      maxPrice: z.number().optional(),
      minPrice: z.number().optional(),
    }),
    execute: async ({ query, category, maxPrice, minPrice }) => {
      try {
        const products = await prisma.product.findMany({
          where: {
            AND: [
              {
                OR: [
                  { name: { contains: query, mode: "insensitive" } },
                  { description: { contains: query, mode: "insensitive" } },
                ],
              },
              category ? { category: { equals: category } } : {},
              maxPrice ? { price: { lte: maxPrice } } : {},
              minPrice ? { price: { gte: minPrice } } : {},
              { stock: { gt: 0 } }, // Only in-stock items
            ],
          },
          take: 10,
        });
 
        if (products.length === 0) {
          return {
            success: false,
            message: "No products found matching your criteria",
          };
        }
 
        return {
          success: true,
          message: `Found ${products.length} products`,
          products: products.map((p) => ({
            id: p.id,
            name: p.name,
            description: p.description,
            price: p.price,
            category: p.category,
            inStock: p.stock > 0,
          })),
        };
      } catch (error) {
        return {
          success: false,
          message: "Failed to search products",
          error: error.message,
        };
      }
    },
  }),
 
  // Get Product Details
  getProductDetails: tool({
    description: "Get detailed information about a specific product",
    parameters: z.object({
      productId: z.string(),
    }),
    execute: async ({ productId }) => {
      try {
        const product = await prisma.product.findUnique({
          where: { id: productId },
        });
 
        if (!product) {
          return {
            success: false,
            message: "Product not found",
          };
        }
 
        return {
          success: true,
          product: {
            id: product.id,
            name: product.name,
            description: product.description,
            price: product.price,
            category: product.category,
            stock: product.stock,
            imageUrl: product.imageUrl,
          },
        };
      } catch (error) {
        return {
          success: false,
          message: "Failed to fetch product details",
        };
      }
    },
  }),
 
  // Cart Management
  addToCart: tool({
    description: "Add a product to user cart",
    parameters: z.object({
      userId: z.string(),
      productId: z.string(),
      quantity: z.number().min(1),
    }),
    execute: async ({ userId, productId, quantity }) => {
      try {
        // Check product availability
        const product = await prisma.product.findUnique({
          where: { id: productId },
        });
 
        if (!product || product.stock < quantity) {
          return {
            success: false,
            message: "Product not available in requested quantity",
          };
        }
 
        // Check if item already in cart
        const existingItem = await prisma.cartItem.findFirst({
          where: {
            userId,
            productId,
          },
        });
 
        if (existingItem) {
          // Update quantity
          await prisma.cartItem.update({
            where: { id: existingItem.id },
            data: { quantity: existingItem.quantity + quantity },
          });
        } else {
          // Add new item
          await prisma.cartItem.create({
            data: {
              userId,
              productId,
              quantity,
            },
          });
        }
 
        return {
          success: true,
          message: `Added ${quantity}x ${product.name} to cart`,
        };
      } catch (error) {
        return {
          success: false,
          message: "Failed to add item to cart",
        };
      }
    },
  }),
 
  // View Cart
  viewCart: tool({
    description: "View all items in user cart",
    parameters: z.object({
      userId: z.string(),
    }),
    execute: async ({ userId }) => {
      try {
        const cartItems = await prisma.cartItem.findMany({
          where: { userId },
          include: { product: true },
        });
 
        if (cartItems.length === 0) {
          return {
            success: true,
            message: "Your cart is empty",
            items: [],
            total: 0,
          };
        }
 
        const total = cartItems.reduce(
          (sum, item) => sum + item.product.price * item.quantity,
          0
        );
 
        return {
          success: true,
          items: cartItems.map((item) => ({
            id: item.id,
            productName: item.product.name,
            quantity: item.quantity,
            price: item.product.price,
            subtotal: item.product.price * item.quantity,
          })),
          total: total.toFixed(2),
        };
      } catch (error) {
        return {
          success: false,
          message: "Failed to fetch cart",
        };
      }
    },
  }),
 
  // Checkout
  checkout: tool({
    description: "Process checkout and create order",
    parameters: z.object({
      userId: z.string(),
      paymentMethodId: z.string(),
      shippingAddress: z.object({
        street: z.string(),
        city: z.string(),
        state: z.string(),
        zipCode: z.string(),
        country: z.string(),
      }),
    }),
    execute: async ({ userId, paymentMethodId, shippingAddress }) => {
      try {
        // Get cart items
        const cartItems = await prisma.cartItem.findMany({
          where: { userId },
          include: { product: true },
        });
 
        if (cartItems.length === 0) {
          return {
            success: false,
            message: "Cart is empty",
          };
        }
 
        // Calculate total
        const total = cartItems.reduce(
          (sum, item) => sum + item.product.price * item.quantity,
          0
        );
 
        // Create order
        const order = await prisma.order.create({
          data: {
            userId,
            total,
            status: "pending",
            items: {
              create: cartItems.map((item) => ({
                productId: item.productId,
                quantity: item.quantity,
                price: item.product.price,
              })),
            },
          },
          include: { items: { include: { product: true } } },
        });
 
        // Process payment (simplified - use Stripe in production)
        // const payment = await stripe.paymentIntents.create({ ... });
 
        // Update order status
        await prisma.order.update({
          where: { id: order.id },
          data: { status: "confirmed" },
        });
 
        // Update product stock
        for (const item of cartItems) {
          await prisma.product.update({
            where: { id: item.productId },
            data: {
              stock: { decrement: item.quantity },
            },
          });
        }
 
        // Clear cart
        await prisma.cartItem.deleteMany({
          where: { userId },
        });
 
        return {
          success: true,
          message: `Order placed successfully! Order ID: ${order.id}`,
          orderId: order.id,
          total: total.toFixed(2),
          estimatedDelivery: "3-5 business days",
        };
      } catch (error) {
        return {
          success: false,
          message: "Checkout failed",
          error: error.message,
        };
      }
    },
  }),
 
  // Order Status
  getOrderStatus: tool({
    description: "Get status of an order",
    parameters: z.object({
      orderId: z.string(),
    }),
    execute: async ({ orderId }) => {
      try {
        const order = await prisma.order.findUnique({
          where: { id: orderId },
          include: {
            items: { include: { product: true } },
          },
        });
 
        if (!order) {
          return {
            success: false,
            message: "Order not found",
          };
        }
 
        return {
          success: true,
          order: {
            id: order.id,
            status: order.status,
            total: order.total,
            createdAt: order.createdAt,
            items: order.items.map((item) => ({
              productName: item.product.name,
              quantity: item.quantity,
              price: item.price,
            })),
          },
        };
      } catch (error) {
        return {
          success: false,
          message: "Failed to fetch order status",
        };
      }
    },
  }),
};

// app/api/chat/route.ts
import { streamText } from "ai";
import { openai } from "@ai-sdk/openai";
import { ecommerceTools } from "@/lib/agents/ecommerce-tools";
 
export const runtime = "edge";
 
export async function POST(req: Request) {
  const { messages, userId } = await req.json();
 
  const result = await streamText({
    model: openai("gpt-4-turbo"),
    system: `You are a helpful e-commerce shopping assistant. You can help users:
    
    1. Create accounts
    2. Search and browse products
    3. Get product details
    4. Add items to cart
    5. View cart
    6. Checkout and place orders
    7. Check order status
    
    Always be friendly, helpful, and guide users through the shopping process.
    When users want to buy something, help them search for products, show details,
    and guide them through adding to cart and checkout.
    
    Current user ID: ${userId || "Not logged in"}
    
    If user is not logged in and tries to add to cart or checkout, suggest they create an account first.`,
    messages,
    tools: ecommerceTools,
    maxToolRoundtrips: 5,
  });
 
  return result.toDataStreamResponse();
}

// app/page.tsx
'use client';
import { useChat } from 'ai/react';
import { useState } from 'react';
 
export default function Home() {
  const [userId, setUserId] = useState<string | null>(null);
  const { messages, input, handleInputChange, handleSubmit, isLoading } = useChat({
    api: '/api/chat',
    body: { userId },
    onFinish: (message) => {
      // Check if message contains userId (from account creation)
      const userIdMatch = message.content.match(/userId: ([a-z0-9-]+)/);
      if (userIdMatch) {
        setUserId(userIdMatch[1]);
        localStorage.setItem('userId', userIdMatch[1]);
      }
    },
  });
 
  return (
    <div className="flex flex-col h-screen bg-gray-50">
      {/* Header */}
      <header className="bg-white border-b px-6 py-4">
        <div className="max-w-4xl mx-auto flex justify-between items-center">
          <h1 className="text-2xl font-bold text-gray-900">
            AI Shopping Assistant
          </h1>
          {userId && (
            <span className="text-sm text-gray-600">
              Logged in
            </span>
          )}
        </div>
      </header>
 
      {/* Chat Messages */}
      <div className="flex-1 overflow-y-auto px-6 py-8">
        <div className="max-w-4xl mx-auto space-y-6">
          {messages.length === 0 && (
            <div className="text-center py-12">
              <h2 className="text-3xl font-bold text-gray-900 mb-4">
                Welcome to AI Shopping! 🛍️
              </h2>
              <p className="text-gray-600 mb-8">
                I can help you shop, manage your cart, and checkout.
              </p>
              <div className="grid md:grid-cols-3 gap-4">
                <button
                  onClick={() => handleInputChange({ target: { value: 'Create an account for me' } } as any)}
                  className="p-4 bg-white rounded-lg border hover:border-blue-500 transition"
                >
                  <div className="text-lg mb-2">👤</div>
                  <div className="font-semibold">Create Account</div>
                </button>
                <button
                  onClick={() => handleInputChange({ target: { value: 'Show me laptops under $1000' } } as any)}
                  className="p-4 bg-white rounded-lg border hover:border-blue-500 transition"
                >
                  <div className="text-lg mb-2">🔍</div>
                  <div className="font-semibold">Browse Products</div>
                </button>
                <button
                  onClick={() => handleInputChange({ target: { value: 'Show my cart' } } as any)}
                  className="p-4 bg-white rounded-lg border hover:border-blue-500 transition"
                >
                  <div className="text-lg mb-2">🛒</div>
                  <div className="font-semibold">View Cart</div>
                </button>
              </div>
            </div>
          )}
 
          {messages.map((message) => (
            <div
              key={message.id}
              className={`flex ${message.role === 'user' ? 'justify-end' : 'justify-start'}`}
            >
              <div
                className={`max-w-3xl px-6 py-4 rounded-2xl ${
                  message.role === 'user'
                    ? 'bg-blue-600 text-white'
                    : 'bg-white border shadow-sm'
                }`}
              >
                {message.content}
              </div>
            </div>
          ))}
 
          {isLoading && (
            <div className="flex justify-start">
              <div className="bg-white border shadow-sm px-6 py-4 rounded-2xl">
                <div className="flex space-x-2">
                  <div className="w-2 h-2 bg-gray-400 rounded-full animate-bounce" />
                  <div className="w-2 h-2 bg-gray-400 rounded-full animate-bounce delay-100" />
                  <div className="w-2 h-2 bg-gray-400 rounded-full animate-bounce delay-200" />
                </div>
              </div>
            </div>
          )}
        </div>
      </div>
 
      {/* Input Bar */}
      <div className="border-t bg-white px-6 py-4">
        <form onSubmit={handleSubmit} className="max-w-4xl mx-auto">
          <div className="flex space-x-4">
            <input
              type="text"
              value={input}
              onChange={handleInputChange}
              placeholder="Ask me anything... (e.g., 'Show me wireless headphones')"
              className="flex-1 px-6 py-3 border rounded-full focus:outline-none focus:ring-2 focus:ring-blue-500"
              disabled={isLoading}
            />
            <button
              type="submit"
              disabled={isLoading || !input.trim()}
              className="px-8 py-3 bg-blue-600 text-white rounded-full hover:bg-blue-700 disabled:opacity-50 disabled:cursor-not-allowed transition"
            >
              Send
            </button>
          </div>
        </form>
      </div>
    </div>
  );
}

// prisma/seed.ts
import { PrismaClient } from "@prisma/client";
 
const prisma = new PrismaClient();
 
async function main() {
  // Create sample products
  await prisma.product.createMany({
    data: [
      {
        name: 'MacBook Pro 16"',
        description: "Powerful laptop for professionals",
        price: 2499.99,
        category: "Electronics",
        stock: 15,
        imageUrl: "/products/macbook.jpg",
      },
      {
        name: "Sony WH-1000XM5",
        description: "Premium noise-cancelling headphones",
        price: 399.99,
        category: "Electronics",
        stock: 30,
        imageUrl: "/products/sony-headphones.jpg",
      },
      {
        name: "iPhone 15 Pro",
        description: "Latest flagship smartphone",
        price: 1199.99,
        category: "Electronics",
        stock: 25,
        imageUrl: "/products/iphone.jpg",
      },
      {
        name: 'Samsung 55" OLED TV',
        description: "4K OLED Smart TV",
        price: 1499.99,
        category: "Electronics",
        stock: 10,
        imageUrl: "/products/samsung-tv.jpg",
      },
      {
        name: "Nike Air Max 270",
        description: "Comfortable running shoes",
        price: 150.0,
        category: "Shoes",
        stock: 50,
        imageUrl: "/products/nike-shoes.jpg",
      },
    ],
  });
 
  console.log("Database seeded!");
}
 
main()
  .catch(console.error)
  .finally(() => prisma.$disconnect());

# Create project
npx create-next-app@latest rag-chat-app
cd rag-chat-app
 
# Install dependencies
npm install ai @ai-sdk/openai zod
npm install @pinecone-database/pinecone
npm install pdf-parse mammoth
npm install multer

// lib/vector-db.ts
import { Pinecone } from "@pinecone-database/pinecone";
import { embed, embedMany } from "ai";
import { openai } from "@ai-sdk/openai";
 
const pinecone = new Pinecone({
  apiKey: process.env.PINECONE_API_KEY!,
});
 
const index = pinecone.index("rag-knowledge-base");
 
export async function embedDocument(
  text: string,
  metadata: {
    source: string;
    title: string;
    chunkIndex: number;
  }
) {
  // Split text into chunks
  const chunks = chunkText(text, 1000);
 
  // Generate embeddings for each chunk
  const { embeddings } = await embedMany({
    model: openai.embedding("text-embedding-3-small"),
    values: chunks,
  });
 
  // Store in Pinecone
  const vectors = chunks.map((chunk, i) => ({
    id: `${metadata.source}-chunk-${i}`,
    values: embeddings[i],
    metadata: {
      text: chunk,
      source: metadata.source,
      title: metadata.title,
      chunkIndex: i,
    },
  }));
 
  await index.upsert(vectors);
 
  return vectors.length;
}
 
export async function searchSimilar(query: string, topK = 5) {
  // Generate query embedding
  const { embedding } = await embed({
    model: openai.embedding("text-embedding-3-small"),
    value: query,
  });
 
  // Search in Pinecone
  const results = await index.query({
    vector: embedding,
    topK,
    includeMetadata: true,
  });
 
  return results.matches.map((match) => ({
    text: match.metadata?.text as string,
    source: match.metadata?.source as string,
    title: match.metadata?.title as string,
    score: match.score,
  }));
}
 
function chunkText(text: string, chunkSize: number): string[] {
  const chunks: string[] = [];
  const sentences = text.match(/[^.!?]+[.!?]+/g) || [text];
 
  let currentChunk = "";
 
  for (const sentence of sentences) {
    if ((currentChunk + sentence).length > chunkSize && currentChunk) {
      chunks.push(currentChunk.trim());
      currentChunk = sentence;
    } else {
      currentChunk += " " + sentence;
    }
  }
 
  if (currentChunk) {
    chunks.push(currentChunk.trim());
  }
 
  return chunks;
}

// lib/document-processor.ts
import pdfParse from "pdf-parse";
import mammoth from "mammoth";
import { embedDocument } from "./vector-db";
 
export async function processDocument(
  file: Buffer,
  filename: string,
  fileType: string
) {
  let text = "";
 
  try {
    if (fileType === "application/pdf") {
      const pdf = await pdfParse(file);
      text = pdf.text;
    } else if (
      fileType ===
      "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
    ) {
      const result = await mammoth.extractRawText({ buffer: file });
      text = result.value;
    } else if (fileType === "text/plain") {
      text = file.toString("utf-8");
    } else {
      throw new Error("Unsupported file type");
    }
 
    // Clean text
    text = text.replace(/\s+/g, " ").trim();
 
    // Embed document
    const chunksCreated = await embedDocument(text, {
      source: filename,
      title: filename.replace(/\.[^/.]+$/, ""),
      chunkIndex: 0,
    });
 
    return {
      success: true,
      message: `Processed ${filename}: ${chunksCreated} chunks created`,
      chunksCreated,
    };
  } catch (error) {
    return {
      success: false,
      message: `Failed to process ${filename}`,
      error: error.message,
    };
  }
}

// lib/agents/rag-tools.ts
import { tool } from "ai";
import { z } from "zod";
import { searchSimilar } from "@/lib/vector-db";
 
export const ragTools = {
  searchKnowledgeBase: tool({
    description: "Search the knowledge base for relevant information",
    parameters: z.object({
      query: z.string(),
      topK: z.number().default(5),
    }),
    execute: async ({ query, topK }) => {
      try {
        const results = await searchSimilar(query, topK);
 
        if (results.length === 0) {
          return {
            success: false,
            message: "No relevant information found in knowledge base",
          };
        }
 
        return {
          success: true,
          results: results.map((r, i) => ({
            rank: i + 1,
            content: r.text,
            source: r.title,
            relevanceScore: r.score?.toFixed(3),
          })),
        };
      } catch (error) {
        return {
          success: false,
          message: "Failed to search knowledge base",
          error: error.message,
        };
      }
    },
  }),
};

// app/api/rag-chat/route.ts
import { streamText } from "ai";
import { openai } from "@ai-sdk/openai";
import { ragTools } from "@/lib/agents/rag-tools";
 
export const runtime = "edge";
 
export async function POST(req: Request) {
  const { messages } = await req.json();
 
  const result = await streamText({
    model: openai("gpt-4-turbo"),
    system: `You are a knowledgeable assistant with access to a custom knowledge base.
    
    When answering questions:
    1. ALWAYS search the knowledge base first using the searchKnowledgeBase tool
    2. Base your answers primarily on the retrieved information
    3. If the knowledge base doesn't have relevant information, clearly state that
    4. Cite sources when providing information from the knowledge base
    5. Be accurate and avoid hallucinating information
    6. If you're uncertain, say so
    
    Format your responses clearly and cite sources like this:
    [Source: Document Title]`,
    messages,
    tools: ragTools,
    maxToolRoundtrips: 3,
  });
 
  return result.toDataStreamResponse();
}

// app/api/upload/route.ts
import { NextRequest, NextResponse } from "next/server";
import { processDocument } from "@/lib/document-processor";
 
export async function POST(req: NextRequest) {
  try {
    const formData = await req.formData();
    const file = formData.get("file") as File;
 
    if (!file) {
      return NextResponse.json({ error: "No file provided" }, { status: 400 });
    }
 
    // Convert to buffer
    const bytes = await file.arrayBuffer();
    const buffer = Buffer.from(bytes);
 
    // Process document
    const result = await processDocument(buffer, file.name, file.type);
 
    return NextResponse.json(result);
  } catch (error) {
    return NextResponse.json(
      { error: "Failed to upload document", details: error.message },
      { status: 500 }
    );
  }
}

// app/page.tsx
'use client';
import { useChat } from 'ai/react';
import { useState, useRef } from 'react';
 
export default function RAGChat() {
  const [uploading, setUploading] = useState(false);
  const [uploadedFiles, setUploadedFiles] = useState<string[]>([]);
  const fileInputRef = useRef<HTMLInputElement>(null);
 
  const { messages, input, handleInputChange, handleSubmit, isLoading } = useChat({
    api: '/api/rag-chat',
  });
 
  const handleFileUpload = async (e: React.ChangeEvent<HTMLInputElement>) => {
    const file = e.target.files?.[0];
    if (!file) return;
 
    setUploading(true);
 
    try {
      const formData = new FormData();
      formData.append('file', file);
 
      const response = await fetch('/api/upload', {
        method: 'POST',
        body: formData,
      });
 
      const result = await response.json();
 
      if (result.success) {
        setUploadedFiles(prev => [...prev, file.name]);
        alert(`✅ ${result.message}`);
      } else {
        alert(`❌ ${result.message}`);
      }
    } catch (error) {
      alert('Failed to upload file');
    } finally {
      setUploading(false);
      if (fileInputRef.current) {
        fileInputRef.current.value = '';
      }
    }
  };
 
  return (
    <div className="flex h-screen bg-gray-50">
      {/* Sidebar */}
      <div className="w-80 bg-white border-r flex flex-col">
        <div className="p-6 border-b">
          <h2 className="text-xl font-bold text-gray-900 mb-4">
            Knowledge Base
          </h2>
          <button
            onClick={() => fileInputRef.current?.click()}
            disabled={uploading}
            className="w-full px-4 py-2 bg-blue-600 text-white rounded-lg hover:bg-blue-700 disabled:opacity-50"
          >
            {uploading ? 'Uploading...' : '📄 Upload Document'}
          </button>
          <input
            ref={fileInputRef}
            type="file"
            accept=".pdf,.docx,.txt"
            onChange={handleFileUpload}
            className="hidden"
          />
        </div>
 
        <div className="flex-1 overflow-y-auto p-6">
          <h3 className="text-sm font-semibold text-gray-700 mb-3">
            Uploaded Documents
          </h3>
          {uploadedFiles.length === 0 ? (
            <p className="text-sm text-gray-500">
              No documents uploaded yet
            </p>
          ) : (
            <div className="space-y-2">
              {uploadedFiles.map((file, i) => (
                <div
                  key={i}
                  className="px-3 py-2 bg-gray-50 rounded text-sm truncate"
                  title={file}
                >
                  📄 {file}
                </div>
              ))}
            </div>
          )}
        </div>
 
        <div className="p-6 border-t">
          <div className="text-xs text-gray-500">
            <p className="mb-2">Supported formats:</p>
            <ul className="list-disc list-inside space-y-1">
              <li>PDF (.pdf)</li>
              <li>Word (.docx)</li>
              <li>Text (.txt)</li>
            </ul>
          </div>
        </div>
      </div>
 
      {/* Chat Area */}
      <div className="flex-1 flex flex-col">
        {/* Header */}
        <header className="bg-white border-b px-6 py-4">
          <h1 className="text-2xl font-bold text-gray-900">
            RAG Chat Assistant
          </h1>
          <p className="text-sm text-gray-600 mt-1">
            Ask questions about your uploaded documents
          </p>
        </header>
 
        {/* Messages */}
        <div className="flex-1 overflow-y-auto px-6 py-8">
          <div className="max-w-4xl mx-auto space-y-6">
            {messages.length === 0 && (
              <div className="text-center py-12">
                <div className="text-6xl mb-4">📚</div>
                <h2 className="text-2xl font-bold text-gray-900 mb-2">
                  Welcome to RAG Chat
                </h2>
                <p className="text-gray-600 mb-8">
                  Upload documents and ask questions about them
                </p>
                <div className="grid md:grid-cols-2 gap-4 max-w-2xl mx-auto">
                  <div className="p-4 bg-white rounded-lg border">
                    <div className="text-lg mb-2">📤</div>
                    <div className="font-semibold mb-1">1. Upload</div>
                    <p className="text-sm text-gray-600">
                      Upload your PDF, Word, or text documents
                    </p>
                  </div>
                  <div className="p-4 bg-white rounded-lg border">
                    <div className="text-lg mb-2">💬</div>
                    <div className="font-semibold mb-1">2. Ask</div>
                    <p className="text-sm text-gray-600">
                      Ask questions about the content
                    </p>
                  </div>
                </div>
              </div>
            )}
 
            {messages.map((message) => (
              <div
                key={message.id}
                className={`flex ${
                  message.role === 'user' ? 'justify-end' : 'justify-start'
                }`}
              >
                <div
                  className={`max-w-3xl px-6 py-4 rounded-2xl ${
                    message.role === 'user'
                      ? 'bg-blue-600 text-white'
                      : 'bg-white border shadow-sm'
                  }`}
                >
                  <div className="prose prose-sm max-w-none">
                    {message.content}
                  </div>
                </div>
              </div>
            ))}
 
            {isLoading && (
              <div className="flex justify-start">
                <div className="bg-white border shadow-sm px-6 py-4 rounded-2xl">
                  <div className="flex space-x-2">
                    <div className="w-2 h-2 bg-gray-400 rounded-full animate-bounce" />
                    <div className="w-2 h-2 bg-gray-400 rounded-full animate-bounce delay-100" />
                    <div className="w-2 h-2 bg-gray-400 rounded-full animate-bounce delay-200" />
                  </div>
                </div>
              </div>
            )}
          </div>
        </div>
 
        {/* Input */}
        <div className="border-t bg-white px-6 py-4">
          <form onSubmit={handleSubmit} className="max-w-4xl mx-auto">
            <div className="flex space-x-4">
              <input
                type="text"
                value={input}
                onChange={handleInputChange}
                placeholder="Ask a question about your documents..."
                className="flex-1 px-6 py-3 border rounded-full focus:outline-none focus:ring-2 focus:ring-blue-500"
                disabled={isLoading || uploadedFiles.length === 0}
              />
              <button
                type="submit"
                disabled={isLoading || !input.trim() || uploadedFiles.length === 0}
                className="px-8 py-3 bg-blue-600 text-white rounded-full hover:bg-blue-700 disabled:opacity-50 disabled:cursor-not-allowed transition"
              >
                Send
              </button>
            </div>
            {uploadedFiles.length === 0 && (
              <p className="text-center text-sm text-gray-500 mt-2">
                Upload documents to start asking questions
              </p>
            )}
          </form>
        </div>
      </div>
    </div>
  );
}