AI Integration

import { createAzure } from '@ai-sdk/azure';

const azure = createAzure({
  resourceName: process.env.NEXT_PUBLIC_AZURE_RESOURCE_NAME!,
  apiKey: process.env.NEXT_PUBLIC_AZURE_API_KEY!,
});

// Model is selected based on speed mode in the request

# Azure AI Configuration
NEXT_PUBLIC_AZURE_RESOURCE_NAME=your-resource-name
NEXT_PUBLIC_AZURE_API_KEY=your-api-key-here
NEXT_PUBLIC_AZURE_FUNCTION_ENDPOINT=https://your-function.azurewebsites.net

import { generateText } from 'ai';
import { model } from '@/lib/ai/provider';

export async function POST(req: Request) {
  const { message, schema } = await req.json();
  
  const { text: sql } = await generateText({
    model,
    system: `You are a SQL expert. Generate SQL queries for the given database schema.
    
    Schema:
    ${JSON.stringify(schema, null, 2)}
    
    Rules:
    - Only generate SELECT queries (read-only)
    - Use proper SQL syntax
    - Include appropriate JOINs when needed
    - Use table aliases for clarity
    - Return only the SQL query, no explanations`,
    prompt: message,
  });
  
  return Response.json({ sql });
}

import { generateObject } from 'ai';
import { z } from 'zod';
import { model } from '@/lib/ai/provider';

const chartConfigSchema = z.object({
  type: z.enum(['bar', 'line', 'pie', 'scatter', 'radar', 'polar']),
  xAxis: z.string().describe('Column name for x-axis'),
  yAxis: z.array(z.string()).describe('Column names for y-axis'),
  title: z.string().describe('Chart title'),
  description: z.string().describe('Brief description'),
});

export async function POST(req: Request) {
  const { query, columns } = await req.json();
  
  const { object: config } = await generateObject({
    model,
    schema: chartConfigSchema,
    system: 'You are a data visualization expert.',
    prompt: `Generate chart config for: "${query}"
    Available columns: ${columns.join(', ')}
    
    Choose the most appropriate chart type and axes.`,
  });
  
  return Response.json({ config });
}

import { generateText } from 'ai';
import { model } from '@/lib/ai/provider';

export async function explainQuery(sql: string): Promise<string> {
  const { text } = await generateText({
    model,
    system: `You are a SQL expert who explains queries to non-technical users.
    Explain what the query does in simple, clear language.`,
    prompt: `Explain this SQL query:

    ${sql}`,
  });
  
  return text;
}

import { generateObject } from 'ai';
import { z } from 'zod';
import { model } from '@/lib/ai/provider';

const suggestionsSchema = z.object({
  suggestions: z.array(z.string()).max(5),
});

export async function getSuggestions(
  userMessage: string,
  schema: any
): Promise<string[]> {
  const { object } = await generateObject({
    model,
    schema: suggestionsSchema,
    system: 'Generate helpful follow-up questions based on the conversation.',
    prompt: `User asked: "${userMessage}"
    
    Database schema: ${JSON.stringify(schema)}
    
    Suggest 5 related questions they might want to ask next.`,
  });
  
  return object.suggestions;
}

import { streamText } from 'ai';
import { model } from '@/lib/ai/provider';

export async function POST(req: Request) {
  const { messages } = await req.json();
  
  const result = await streamText({
    model,
    messages,
    system: 'You are a helpful data analysis assistant.',
  });
  
  return result.toDataStreamResponse();
}

import { useChat } from '@ai-sdk/react';

export function Chat() {
  const { messages, input, handleInputChange, handleSubmit } = useChat({
    api: '/api/chat',
  });
  
  return (
    <form onSubmit={handleSubmit}>
      {messages.map(m => (
        <div key={m.id}>
          {m.role}: {m.content}
        </div>
      ))}
      <input
        value={input}
        onChange={handleInputChange}
        placeholder="Ask a question..."
      />
    </form>
  );
}

import { AIError } from 'ai';

export async function handleAIOperation<T>(
  operation: () => Promise<T>
): Promise<T> {
  try {
    return await operation();
  } catch (error) {
    if (error instanceof AIError) {
      // Handle specific AI errors
      if (error.name === 'AI_RateLimitError') {
        throw new Error('Rate limit exceeded. Please try again later.');
      }
      if (error.name === 'AI_InvalidRequestError') {
        throw new Error('Invalid request. Please rephrase your question.');
      }
    }
    
    // Generic error
    console.error('AI operation failed:', error);
    throw new Error('AI operation failed. Please try again.');
  }
}

import { Ratelimit } from '@upstash/ratelimit';
import { Redis } from '@upstash/redis';

const ratelimit = new Ratelimit({
  redis: Redis.fromEnv(),
  limiter: Ratelimit.slidingWindow(10, '1 m'),
});

export async function middleware(request: Request) {
  const ip = request.headers.get('x-forwarded-for') ?? 'unknown';
  const { success } = await ratelimit.limit(ip);
  
  if (!success) {
    return new Response('Rate limit exceeded', { status: 429 });
  }
  
  return NextResponse.next();
}

import { generateText } from 'ai';
import { model } from '@/lib/ai/provider';

export async function generateWithTracking(
  prompt: string,
  userId: string
) {
  const result = await generateText({
    model,
    prompt,
  });
  
  // Log token usage
  await logTokenUsage({
    userId,
    promptTokens: result.usage?.promptTokens ?? 0,
    completionTokens: result.usage?.completionTokens ?? 0,
    totalTokens: result.usage?.totalTokens ?? 0,
  });
  
  return result.text;
}