Vercel AI Cloud: Zero-Config Backend Deployment Guide

# Project structure
project/
├── api/
│   ├── __init__.py
│   └── main.py          # Your FastAPI/Flask app
├── requirements.txt     # Dependencies
└── vercel.json          # Optional advanced configuration

# Optional: pin Python in pyproject.toml
[project]
requires-python = ">=3.12"

# api/main.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List, Optional

app = FastAPI(
    title="AI Content API",
    description="Vercel-deployed FastAPI application",
    version="1.0.0"
)

class ContentRequest(BaseModel):
    topic: str
    length: int = 500
    tone: Optional[str] = "professional"

class ContentResponse(BaseModel):
    content: str
    word_count: int
    processing_time: float

@app.get("/")
async def root():
    return {
        "message": "FastAPI on Vercel AI Cloud",
        "status": "healthy",
        "framework": "FastAPI"
    }

@app.get("/health")
async def health_check():
    return {"status": "ok", "platform": "Vercel AI Cloud"}

@app.post("/api/generate", response_model=ContentResponse)
async def generate_content(request: ContentRequest):
    """
    Generate AI content based on topic and parameters.
    Vercel automatically scales this endpoint based on load.
    """
    import time
    start_time = time.time()

    # Simulate AI content generation
    # In production, call OpenAI, Claude, etc.
    content = f"AI-generated content about {request.topic}..."
    word_count = len(content.split())

    processing_time = time.time() - start_time

    return ContentResponse(
        content=content,
        word_count=word_count,
        processing_time=processing_time
    )

@app.get("/api/topics", response_model=List[str])
async def list_topics():
    """
    List available content topics.
    Edge-optimized endpoint with automatic caching.
    """
    return [
        "AI & Machine Learning",
        "Web Development",
        "Cloud Computing",
        "Data Science",
        "DevOps"
    ]

# api/main.py
from flask import Flask, jsonify, request
from datetime import datetime
import os

app = Flask(__name__)

@app.route('/')
def home():
    return jsonify({
        'message': 'Flask on Vercel AI Cloud',
        'timestamp': datetime.utcnow().isoformat(),
        'framework': 'Flask'
    })

@app.route('/api/process', methods=['POST'])
def process_data():
    """
    Process incoming data with automatic scaling.
    Vercel provisions compute based on request patterns.
    """
    data = request.get_json()

    if not data:
        return jsonify({'error': 'No data provided'}), 400

    # Process data (call AI models, database, etc.)
    result = {
        'status': 'processed',
        'input_keys': list(data.keys()),
        'processed_at': datetime.utcnow().isoformat()
    }

    return jsonify(result)

@app.route('/api/config')
def get_config():
    """
    Access environment variables securely.
    Vercel manages secrets automatically.
    """
    return jsonify({
        'environment': os.getenv('VERCEL_ENV', 'development'),
        'region': os.getenv('VERCEL_REGION', 'auto'),
        'python_version': os.getenv('PYTHON_VERSION', '3.12')
    })

if __name__ == '__main__':
    app.run(debug=True)

# requirements.txt
fastapi==0.115.0
pydantic==2.9.0
uvicorn==0.32.0

# Or for Flask
flask==3.0.3
flask-cors==5.0.0

# Method 1: Git deployment (automatic)
git add .
git commit -m "Deploy FastAPI to Vercel"
git push origin main

# Method 2: Vercel CLI
npm install -g vercel
vercel deploy

# Result: Your Python API is live globally in seconds
# URL: https://your-project.vercel.app

// api/server.ts
import express, { Request, Response, NextFunction } from 'express';
import cors from 'cors';

const app = express();

// Middleware
app.use(cors());
app.use(express.json());

// Logging middleware
app.use((req: Request, res: Response, next: NextFunction) => {
  console.log(`${req.method} ${req.path}`);
  next();
});

// Health check
app.get('/api/health', (req: Request, res: Response) => {
  res.json({
    status: 'healthy',
    timestamp: new Date().toISOString(),
    platform: 'Vercel AI Cloud',
    framework: 'Express'
  });
});

// AI endpoint with automatic scaling
app.post('/api/analyze', async (req: Request, res: Response) => {
  try {
    const { text, model = 'gpt-5' } = req.body;

    if (!text) {
      return res.status(400).json({ error: 'Text is required' });
    }

    // Call AI service (OpenAI, Claude, etc.)
    const result = {
      analysis: `Analysis of: ${text.substring(0, 50)}...`,
      model,
      confidence: 0.95,
      processed_at: new Date().toISOString()
    };

    res.json(result);
  } catch (error) {
    res.status(500).json({
      error: 'Processing failed',
      message: error.message
    });
  }
});

// Streaming endpoint
app.get('/api/stream', (req: Request, res: Response) => {
  res.setHeader('Content-Type', 'text/event-stream');
  res.setHeader('Cache-Control', 'no-cache');
  res.setHeader('Connection', 'keep-alive');

  let count = 0;
  const interval = setInterval(() => {
    res.write(`data: ${JSON.stringify({ count: ++count })}

`);

    if (count >= 10) {
      clearInterval(interval);
      res.end();
    }
  }, 1000);
});

export default app;

// api/hono.ts
import { Hono } from 'hono';
import { cors } from 'hono/cors';

const app = new Hono();

// Enable CORS
app.use('/*', cors());

// HTTP API response
app.get('/api/data', async (c) => {
  const data = {
    message: 'Served by Hono on Vercel Functions',
    timestamp: Date.now(),
    region: c.req.header('x-vercel-ip-region')
  };

  return c.json(data);
});

// AI generation endpoint
app.post('/api/generate', async (c) => {
  const body = await c.req.json();

  // Call AI providers, databases, or internal services
  const response = {
    generated: `Content for: ${body.prompt}`,
    model: 'api-orchestrated'
  };

  return c.json(response);
});

export default app;

// src/app.controller.ts
import { Controller, Get, Post, Body } from '@nestjs/common';
import { AppService } from './app.service';

interface GenerateDto {
  prompt: string;
  model?: string;
}

@Controller('api')
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get('health')
  getHealth() {
    return {
      status: 'healthy',
      framework: 'NestJS',
      platform: 'Vercel AI Cloud'
    };
  }

  @Post('generate')
  async generate(@Body() dto: GenerateDto) {
    return await this.appService.generateContent(dto);
  }

  @Get('models')
  async getModels() {
    return await this.appService.listModels();
  }
}

// src/app.service.ts
import { Injectable } from '@nestjs/common';

@Injectable()
export class AppService {
  async generateContent(dto: GenerateDto) {
    // Call AI service with dependency injection
    return {
      content: `Generated from: ${dto.prompt}`,
      model: dto.model || 'gpt-5',
      timestamp: new Date().toISOString()
    };
  }

  async listModels() {
    return ['gpt-5', 'gpt-4.1', 'claude-sonnet-4.5'];
  }
}

// package.json
{
  "name": "vercel-ai-backend",
  "version": "1.0.0",
  "type": "module",
  "scripts": {
    "dev": "tsx api/server.ts",
    "build": "tsc",
    "start": "node dist/api/server.js"
  },
  "dependencies": {
    "express": "^4.19.2",
    "hono": "^4.6.0",
    "@nestjs/core": "^10.4.0",
    "cors": "^2.8.5"
  },
  "devDependencies": {
    "@types/express": "^4.17.21",
    "@types/node": "^22.5.0",
    "typescript": "^5.5.4",
    "tsx": "^4.19.0"
  }
}

// app/workflows/content-pipeline.ts
// Install with: pnpm i workflow

interface ContentJob {
  topic: string;
  targetLength: number;
  style: string;
}

export async function contentPipeline(job: ContentJob) {
  'use workflow';

  const research = await researchTopic(job.topic);

  const outline = await generateOutline(research, job.targetLength);

  const sections = await Promise.all(
    outline.sections.map((section) =>
      writeSection(section, job.style)
    )
  );

  const finalContent = await editContent(sections);

  await storeContent(finalContent);
  await notifyCompletion(job.topic);

  return {
    content: finalContent,
    wordCount: finalContent.split(' ').length,
    completedAt: new Date().toISOString()
  };
}

async function researchTopic(topic: string) {
  'use step';
  // Call external APIs with built-in retries and persisted step output.
  return { sources: [], keyPoints: [] };
}

async function generateOutline(
  research: { sources: string[]; keyPoints: string[] },
  length: number
) {
  'use step';
  return { sections: ['Introduction', 'Implementation'] };
}

async function writeSection(section: string, style: string) {
  'use step';
  return { title: '', content: '' };
}

async function editContent(sections: Array<{ title: string; content: string }>) {
  'use step';
  return sections.map((section) => section.content).join('

');
}

async function storeContent(content: string) {
  'use step';
  await saveContent(content);
}

async function notifyCompletion(topic: string) {
  'use step';
  await sendNotification(topic);
}

// app/workflows/daily-report.ts
import { sleep } from 'workflow';

export async function delayedDailyReport(reportId: string) {
  'use workflow';

  // Pause without consuming compute, then resume from this point.
  await sleep('24 hours');

  const analytics = await fetchAnalytics();
  const sales = await fetchSales();
  const traffic = await fetchTraffic();

  // Generate AI summary
  const summary = await generateAISummary({
    analytics,
    sales,
    traffic
  });

  await sendReport(summary);

  return { reportId, status: 'completed', timestamp: Date.now() };
}

// For fixed wall-clock schedules, trigger workflows from Vercel Cron
// or the current Workflow scheduling pattern in the Vercel docs.

// app/workflows/ai-agent.ts

interface AgentTask {
  goal: string;
  context: Record<string, unknown>;
}

export async function aiAgent(task: AgentTask) {
  'use workflow';

  const steps: string[] = [];
  let iterations = 0;
  const maxIterations = 10;

  // Agent loop with state persistence
  while (iterations < maxIterations) {
    // Reasoning step
    const thought = await agentThink({
      goal: task.goal,
      context: task.context,
      previousSteps: steps
    });

    steps.push(thought.action);

    // Check if goal is achieved
    if (thought.goalAchieved) {
      break;
    }

    // Execute action
    const result = await executeAction(thought.action);

    // Update context with results
    task.context = { ...task.context, ...result };

    iterations++;
  }

  return {
    goal: task.goal,
    steps,
    iterations,
    finalContext: task.context
  };
}

async function agentThink(params: {
  goal: string;
  context: Record<string, unknown>;
  previousSteps: string[];
}) {
  'use step';
  return { action: '', goalAchieved: false };
}

async function executeAction(action: string) {
  'use step';
  return {};
}

# Set via Vercel Dashboard or CLI
vercel env add OPENAI_API_KEY
vercel env add DATABASE_URL

# Access in code (Python)
import os
api_key = os.getenv('OPENAI_API_KEY')

# Access in code (TypeScript)
const apiKey = process.env.OPENAI_API_KEY;

// Robust error handling pattern
export async function POST(request: Request) {
  try {
    const body = await request.json();
    const result = await processData(body);

    return new Response(JSON.stringify(result), {
      status: 200,
      headers: { 'Content-Type': 'application/json' }
    });
  } catch (error) {
    // Log for Vercel Analytics
    console.error('Processing failed:', {
      error: error.message,
      stack: error.stack,
      timestamp: new Date().toISOString()
    });

    // Return graceful error
    return new Response(JSON.stringify({
      error: 'Processing failed',
      requestId: crypto.randomUUID()
    }), {
      status: 500,
      headers: { 'Content-Type': 'application/json' }
    });
  }
}

# Create preview deployment for testing
git checkout -b feature/new-endpoint
git push origin feature/new-endpoint

# Vercel automatically creates preview URL
# Test at: https://your-project-git-feature-new-endpoint.vercel.app

# Merge to production when ready
git checkout main
git merge feature/new-endpoint
git push origin main