Back to Blog
AI Agents
October 13, 2025
14 min read

Building Agentic Workflows for Restaurant Discovery

Discover how to build intelligent AI agents that help users find the perfect restaurant based on specific queries like "lunch buffet near me" or "continental breakfast downtown" using modern AI frameworks and location-based services.

What Are Agentic Workflows?

Agentic workflows are AI-powered systems that can autonomously plan, execute, and adapt their actions to achieve specific goals. Unlike traditional chatbots, agents can break down complex queries, use multiple tools, and make decisions based on context.

The Restaurant Discovery Challenge

Finding the right restaurant involves multiple factors: location, cuisine type, meal timing, price range, dietary restrictions, and specific amenities like buffets or outdoor seating. Traditional search requires users to manually filter through multiple criteria. An agentic workflow can understand natural language queries and orchestrate multiple API calls to deliver precise results.

Architecture Overview

User Query → Agent Orchestrator → Tools
                                    ↓
                    ┌───────────────┼───────────────┐
                    ↓               ↓               ↓
              Location API    Restaurant DB    Review API
                    ↓               ↓               ↓
                    └───────────────┼───────────────┘
                                    ↓
                            Result Aggregator
                                    ↓
                            Formatted Response

Example Query Scenarios

Continental Breakfast

"Find hotels or cafes serving continental breakfast within 2 miles"

• Filter: Breakfast hours (6 AM - 11 AM)

• Cuisine: Continental, European

• Amenities: Coffee, pastries, buffet

Lunch Buffet

"Show me Indian restaurants with lunch buffet under $20"

• Filter: Lunch hours (11 AM - 3 PM)

• Cuisine: Indian

• Price: $ - $$

• Feature: All-you-can-eat buffet

Building the Agent

We'll use the AI SDK with tool calling capabilities to create an agent that can understand queries and use multiple tools to find restaurants.

Step 1: Define the Tools

import { tool } from 'ai';
import { z } from 'zod';

const getLocationTool = tool({
  description: 'Get user location coordinates',
  parameters: z.object({
    address: z.string().describe('Address or "current location"'),
  }),
  execute: async ({ address }) => {
    // Use geocoding API
    const coords = await geocode(address);
    return { lat: coords.lat, lng: coords.lng };
  },
});

const searchRestaurantsTool = tool({
  description: 'Search restaurants by criteria',
  parameters: z.object({
    location: z.object({
      lat: z.number(),
      lng: z.number(),
    }),
    cuisine: z.string().optional(),
    mealType: z.enum(['breakfast', 'lunch', 'dinner']).optional(),
    features: z.array(z.string()).optional(),
    priceRange: z.enum(['$', '$$', '$$$', '$$$$']).optional(),
    radius: z.number().default(5), // miles
  }),
  execute: async (params) => {
    // Query restaurant database/API
    const results = await queryRestaurants(params);
    return results;
  },
});

Step 2: Create the Agent

import { generateText } from 'ai';

async function findRestaurants(query: string) {
  const { text, toolCalls } = await generateText({
    model: 'gpt-4',
    prompt: `You are a restaurant discovery assistant. 
    Help the user find restaurants based on their query: "${query}"
    
    Use the available tools to:
    1. Get the user's location
    2. Search for restaurants matching their criteria
    3. Provide detailed recommendations`,
    tools: {
      getLocation: getLocationTool,
      searchRestaurants: searchRestaurantsTool,
    },
    maxSteps: 5, // Allow multi-step reasoning
  });

  return { recommendations: text, toolCalls };
}

Step 3: Handle Complex Queries

// Example: "Find Indian lunch buffets under $20 near downtown"

const result = await findRestaurants(
  "Find Indian lunch buffets under $20 near downtown Seattle"
);

// Agent reasoning:
// 1. Extract location: "downtown Seattle"
// 2. Call getLocation({ address: "downtown Seattle" })
// 3. Extract criteria: cuisine=Indian, mealType=lunch, 
//    features=["buffet"], priceRange="$-$$"
// 4. Call searchRestaurants with all parameters
// 5. Format and return top recommendations

Integrating Location Services

Location is crucial for restaurant discovery. Here's how to integrate Google Places API or similar services:

import { Client } from '@googlemaps/google-maps-services-js';

const client = new Client({});

async function searchNearbyRestaurants(params) {
  const response = await client.placesNearby({
    params: {
      location: { lat: params.lat, lng: params.lng },
      radius: params.radius * 1609.34, // miles to meters
      type: 'restaurant',
      keyword: params.features?.join(' '),
      key: process.env.GOOGLE_MAPS_API_KEY,
    },
  });

  // Filter by meal type and price
  const filtered = response.data.results.filter(place => {
    const matchesMealType = checkMealType(place, params.mealType);
    const matchesPrice = place.price_level <= getPriceLevel(params.priceRange);
    return matchesMealType && matchesPrice;
  });

  return filtered.map(place => ({
    name: place.name,
    address: place.vicinity,
    rating: place.rating,
    priceLevel: '$'.repeat(place.price_level || 1),
    isOpen: place.opening_hours?.open_now,
  }));
}

Advanced Features

Time-Aware Filtering

Automatically filter restaurants based on current time and meal periods:

  • Breakfast: 6 AM - 11 AM
  • Lunch: 11 AM - 3 PM
  • Dinner: 5 PM - 10 PM
  • Late night: 10 PM - 2 AM

Review Integration

Integrate with Yelp or Google Reviews to provide sentiment analysis and highlight specific features mentioned in reviews (e.g., "great buffet selection", "authentic continental breakfast").

Dynamic Pricing

Track special offers, happy hour deals, and lunch specials to provide cost-effective recommendations.

Example User Interaction

User:

"I want a lunch buffet with Indian food, preferably under $15"

Agent:

I found 3 Indian restaurants with lunch buffets near you:

Taj Palace

0.8 miles • $$ • ⭐ 4.5 (230 reviews)

Lunch buffet: $12.99 • Open until 3 PM • Vegetarian options

Spice Garden

1.2 miles • $ • ⭐ 4.3 (180 reviews)

Lunch buffet: $10.99 • Open until 2:30 PM • Extensive buffet selection

Curry House

1.5 miles • $$ • ⭐ 4.4 (195 reviews)

Lunch buffet: $13.99 • Open until 3 PM • Popular for tandoori dishes

Best Practices

1

Cache Location Data

Store user location preferences to avoid repeated geocoding API calls.

2

Handle Ambiguity

When queries are unclear, ask clarifying questions before making API calls.

3

Optimize API Usage

Batch requests and implement rate limiting to stay within API quotas.

4

Provide Fallbacks

If no exact matches are found, suggest nearby alternatives or broaden the search criteria.

Conclusion

Agentic workflows transform restaurant discovery from a manual, multi-step process into an intelligent, conversational experience. By combining natural language understanding, tool orchestration, and location-based services, you can build systems that truly understand user intent and deliver personalized recommendations. The key is designing agents that can reason about complex queries, use multiple data sources, and adapt to user preferences over time.

Continue Reading

Explore more articles on software engineering and technology

AI Tools

How to Make Best Use of Cursor AI for Development

Discover how Cursor AI is revolutionizing software development with intelligent code completion and AI-powered refactoring.

15 min read
Read
Development

How to Leverage v0 to Build Your Professional Portfolio

Discover how v0's AI-powered development platform can help you create a stunning portfolio website in minutes.

8 min read
Read
Architecture

Buffet: A Delightful Microfront-end Architecture

Introducing Buffet, a revolutionary microfront-end architecture designed to dramatically increase app delivery velocity.

15 min read
Read