How to Integrate MongoDB Atlas with V0

If you have not already created an Atlas cluster, go to cloud.mongodb.com, sign in, and create a new project. Click Build a Database, select the free M0 shared cluster, choose your preferred cloud provider and region (choose a region close to your Vercel deployment region — iad1 for US East), and click Create. After the cluster is created, configure database access: go to Database Access → Add New Database User. Create a username and password (use a strong generated password). Grant 'Read and write to any database' permissions for development. Then configure network access: go to Network Access → Add IP Address. For Vercel deployments, add 0.0.0.0/0 (Allow Access from Anywhere) since Vercel serverless functions use dynamic IP addresses. In production, consider restricting to Vercel's IP ranges. To get your connection string: go to Database → Connect → Drivers → Node.js → copy the connection string. It looks like: mongodb+srv://username:password@cluster0.abc123.mongodb.net/?retryWrites=true&w=majority. Replace the {password} placeholder with your actual password. This is your MONGODB_URI that goes into Vercel environment variables. For Atlas Search, you also need to create a search index: go to Atlas Search in your cluster, click Create Search Index, select your database and collection, and create a default index. Atlas Search requires at least an M2 cluster — M0 free tier does not support Atlas Search.

Install the MongoDB driver in your project by adding 'mongodb' to your package.json. In V0, you can ask V0 to add the dependency in a prompt, or add it manually to package.json. The driver handles connection pooling and reconnection automatically. Create app/api/atlas/route.ts as your main database API route. The critical pattern for Next.js serverless functions is to cache the MongoDB client connection to avoid creating a new connection on every function invocation. Serverless functions can be invoked hundreds of times per second, and creating a new MongoDB connection for each invocation would exhaust Atlas connection limits quickly. The standard pattern stores the cached client in a module-level variable that persists across warm invocations. The route should handle GET requests (query documents) and POST requests (create documents) as a starting point. Add query parameters for filtering — collection name, query object, sort, limit. This makes the route reusable across different collections in your app without creating separate routes for each collection. Atlas connection strings use the SRV format (mongodb+srv://) which handles DNS-based server discovery automatically.

1import { NextRequest, NextResponse } from 'next/server';
2import { MongoClient, ServerApiVersion } from 'mongodb';
3
4// Cache the client across serverless function invocations
5let cachedClient: MongoClient | null = null;
6
7async function getClient(): Promise<MongoClient> {
8  if (cachedClient) return cachedClient;
9
10  const uri = process.env.MONGODB_URI;
11  if (!uri) throw new Error('MONGODB_URI environment variable not set');
12
13  const client = new MongoClient(uri, {
14    serverApi: {
15      version: ServerApiVersion.v1,
16      strict: true,
17      deprecationErrors: true,
18    },
19  });
20
21  await client.connect();
22  cachedClient = client;
23  return client;
24}
25
26export async function GET(request: NextRequest) {
27  const { searchParams } = new URL(request.url);
28  const collection = searchParams.get('collection') || 'documents';
29  const limit = parseInt(searchParams.get('limit') || '20');
30
31  try {
32    const client = await getClient();
33    const db = client.db(process.env.MONGODB_DB_NAME || 'myapp');
34    const docs = await db.collection(collection).find({}).limit(limit).toArray();
35
36    return NextResponse.json({ data: docs, count: docs.length });
37  } catch (error) {
38    console.error('MongoDB Atlas error:', error);
39    return NextResponse.json(
40      { error: 'Database query failed' },
41      { status: 500 }
42    );
43  }
44}
45
46export async function POST(request: NextRequest) {
47  const body = await request.json();
48  const collection = body.collection || 'documents';
49  const document = body.data;
50
51  if (!document) {
52    return NextResponse.json({ error: 'Document data is required' }, { status: 400 });
53  }
54
55  try {
56    const client = await getClient();
57    const db = client.db(process.env.MONGODB_DB_NAME || 'myapp');
58    const result = await db.collection(collection).insertOne({
59      ...document,
60      createdAt: new Date(),
61    });
62
63    return NextResponse.json({ id: result.insertedId });
64  } catch (error) {
65    console.error('MongoDB Atlas error:', error);
66    return NextResponse.json(
67      { error: 'Failed to create document' },
68      { status: 500 }
69    );
70  }
71}

Atlas Search uses MongoDB aggregation pipelines with a $search stage. This is the key difference from standard MongoDB queries — instead of using find() with regex patterns, you use aggregate() with $search as the first stage. The $search stage supports full-text search, fuzzy matching, autocomplete, phrase queries, and relevance scoring. Create app/api/atlas/search/route.ts. The $search aggregation stage accepts a compound query with text, fuzzy, phrase, and range operators. For a basic product search, the text operator with fuzzy matching enabled handles typos and partial matches. Atlas adds a computed score to each result that you can use to sort by relevance. Atlas Search requires creating a search index on your collection before you can query it. Go to your Atlas cluster → Atlas Search → Create Search Index. Use the default dynamic index which automatically maps all string fields. For production, create a custom index mapping specific fields to control what is searchable and how. Atlas Search is available on M2 clusters and above ($9/month) — the M0 free tier does not support it. If you need search on M0, use MongoDB's text index ($text operator) as a fallback, though it lacks Atlas Search's fuzzy matching and relevance scoring.

1import { NextRequest, NextResponse } from 'next/server';
2import { MongoClient, ServerApiVersion } from 'mongodb';
3
4let cachedClient: MongoClient | null = null;
5
6async function getClient(): Promise<MongoClient> {
7  if (cachedClient) return cachedClient;
8  const client = new MongoClient(process.env.MONGODB_URI!, {
9    serverApi: { version: ServerApiVersion.v1, strict: true, deprecationErrors: true },
10  });
11  await client.connect();
12  cachedClient = client;
13  return client;
14}
15
16export async function GET(request: NextRequest) {
17  const { searchParams } = new URL(request.url);
18  const query = searchParams.get('q');
19  const collection = searchParams.get('collection') || 'products';
20
21  if (!query) {
22    return NextResponse.json({ error: 'Search query is required' }, { status: 400 });
23  }
24
25  try {
26    const client = await getClient();
27    const db = client.db(process.env.MONGODB_DB_NAME || 'myapp');
28
29    // Atlas Search aggregation pipeline
30    const results = await db.collection(collection).aggregate([
31      {
32        $search: {
33          index: 'default', // Name of your Atlas Search index
34          compound: {
35            should: [
36              {
37                text: {
38                  query,
39                  path: { wildcard: '*' }, // Search all string fields
40                  fuzzy: { maxEdits: 1 },  // Allow 1 character typo
41                  score: { boost: { value: 2 } },
42                },
43              },
44            ],
45          },
46        },
47      },
48      { $addFields: { searchScore: { $meta: 'searchScore' } } },
49      { $sort: { searchScore: -1 } },
50      { $limit: 20 },
51    ]).toArray();
52
53    return NextResponse.json({ results, count: results.length });
54  } catch (error) {
55    console.error('Atlas Search error:', error);
56    return NextResponse.json(
57      { error: 'Search failed' },
58      { status: 500 }
59    );
60  }
61}

Add your MongoDB Atlas credentials to Vercel environment variables. You need MONGODB_URI (the full connection string) and optionally MONGODB_DB_NAME (database name). Never use NEXT_PUBLIC_ prefix for database credentials — they must remain server-only. In Vercel Dashboard → Settings → Environment Variables, add MONGODB_URI with your full Atlas connection string. It must include the database username and password embedded in the URL: mongodb+srv://username:yourpassword@cluster0.abc123.mongodb.net/?retryWrites=true&w=majority. Also add MONGODB_DB_NAME with your database name (e.g., 'myapp' or 'production'). For security: ensure the Atlas database user's password in the connection string does not contain URL-special characters (%, @, #, :, /) — these must be percent-encoded if present. The best practice is to generate a random alphanumeric password with no special characters for database users. After deploying, test your Atlas Search endpoint with a real query against your collection. If you populated test data in Atlas, search for a term that should match. Check Vercel Function Logs if results are not returning — Atlas connection errors and search index issues will appear there.