Let's talk.

Whether it's a project, a role, or you just want to say hi, my inbox is open.

kadhar.mfn@gmail.com
AboutExperienceProjectsWritingFree guidesToolsGames

© 2026 Kadharmoideen Fadurudeen. Made with care.

Kadhar
AboutExperienceProjectsWritingFree guides
Tools
Say hello
Back to Blog
AI Agents
October 13, 2025
14 min read

Building Agentic Workflows for Restaurant Discovery

Learn how to create intelligent AI agents that help users discover nearby restaurants based on specific queries like lunch buffets, continental breakfast, and more using modern AI frameworks.

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.

PreviousHow to Make Best Use of Cursor AI for DevelopmentNextLet Users Speak Naturally — and Let AI Handle the Filters

Continue Reading

Explore more articles on software engineering and technology

AI Agents

Combo Maker: Building a Budget-Aware Meal Recommender

Give it a budget and a diet preference, and Combo Maker assembles the best meal combo it can afford from a sample menu — a live demo, how the allocator works, and an honest look at what a real AI-backed version would need.

9 min read
Read
AI Agents

Building a Multi-Agent System from Scratch: Architecture Patterns

Orchestrator-worker, blackboard, and pipeline patterns for coordinating multiple AI agents — with the failure modes that only show up once you go past a single-agent demo.

11 min read
Read
Architecture

Framework-Agnostic Frontend Architecture: Migrate from Angular to React Without a Rewrite

Make the UI framework a swappable detail: MVC vs. React's 'just the view', a plain-TypeScript core, Web Components, an app shell that runs Angular and React side by side, and a safe step-by-step migration plan, with a live demo.

16 min read
Read