A Comprehensive Guide:

AI Agents to Suggest Menus for

Themed Restaurant

Using with Genkit and Ollama

1 ANSHUMAN JHA
A Comprehensive Guide: AI-Agents Menu Suggestions with Genkit and Ollama

Table of Contents
Introduction
• Firebase Gen Kit and Its Advantages
• Benefits of Using Ollama for Local Development
• Tutorial Goal: Building a Simple AI Application

Use Case Story and Background

• Project Context
• Real-World Applications

Setting Up the Environment

• Downloading and Installing Ollama
• Creating a New Project Directory and Initializing a Node.js Application
• Installing Gen Kit Globally

Exploring Gen Kit UI

• Concept of Flows in Gen Kit UI
• Running the Default Flow and Providing Input
• Viewing and Analyzing Workflow Trace for Debugging
• Exploring Different Models and Options

Building a Simple Application

• Example Application and Its Functionality
• Code Snippet Explanation
• Modifying the Prompt and Testing Different Inputs
• Running the Workflow within the Node.js Application

Debugging and Testing

• Testing the Workflow Directly from the Terminal
• Tips and Best Practices for Troubleshooting

Purposed Cloud Architecture Diagram

• Detailed diagram of Cloud Architecture Diagram
• Components of Cloud Architecture Diagram

Conclusion
• Recap of Key Concepts and Steps
• Encouragement to Explore Further
• Additional Resources and Documentation

2 ANSHUMAN JHA
A Comprehensive Guide: AI-Agents Menu Suggestions with Genkit and Ollama

1. Introduction
Firebase Gen Kit and Its Advantages
Firebase Gen Kit is a comprehensive toolkit that simplifies the development and deployment of AI applications.
It provides pre-built components and workflows that can be easily customized, allowing developers to focus
on the core logic of their applications.

Benefits of Using Ollama for Local Development

Ollama is a local development tool that enables you to run and test AI models on your machine. This avoids
the latency and costs associated with cloud-based solutions and provides a controlled environment for
development and debugging.

Tutorial Goal: Building a Simple AI Application

In this tutorial, we will build a simple application that suggests menu items for themed restaurants using Gen
Kit and Ollama. This will involve setting up the environment, exploring the Gen Kit UI, building and running a
workflow, and debugging the application.

2. Use Case Story and Background

Project Context
Imagine you are a restaurant owner who wants to create a unique dining experience by offering themed menu
suggestions. By leveraging AI, you can generate creative and diverse menu items that match different themes,
such as French, Italian, or Japanese cuisine.

Real-World Applications
An AI-powered menu suggestion system can help restaurant owners enhance their offerings, attract more
customers, and streamline their menu planning process. It can also be used by chefs to experiment with new
dishes and by food bloggers to generate content ideas.

3 ANSHUMAN JHA
A Comprehensive Guide: AI-Agents Menu Suggestions with Genkit and Ollama

2. Project Structure
genkit-ollama/
├── src/
│ ├── main.ts
├── package.json
├── tsconfig.json

3. Step-by-Step Guide
Downloading and Installing Ollama

1. Visit the Ollama website and download the latest version of Ollama.
2. Follow the installation instructions for your operating system.
3. Verify the installation by running ollama --version in your terminal.

Creating a New Project Directory and Initializing a Node.js Application

1. Open your terminal and create a new project directory:

mkdir genkit-ollama
cd genkit-ollama

2. Initialize a new Node.js application:

npm init -y

Installing Gen Kit Globally

1. Install Gen Kit globally using npm:

npm install -g genkit

2. Initialize Gen Kit in your project director

genkit init

4 ANSHUMAN JHA
A Comprehensive Guide: AI-Agents Menu Suggestions with Genkit and Ollama

4. Exploring Gen Kit UI

Concept of Flows in Gen Kit UI

Flows in Gen Kit UI represent workflows that define how data is processed and transformed. Each flow
consists of a series of steps, such as data input, processing, and output.

Running the Default Flow and Providing Input

1. Start Gen Kit:

genkit start

2. Open Gen Kit UI in your browser by navigating to http://localhost:3000.

3. Run the default flow by selecting it from the list and providing the necessary input.

Viewing and Analyzing Workflow Trace for Debugging

1. After running the flow, view the trace in Gen Kit UI to see each step's execution details.
2. Use the trace to identify any errors or bottlenecks in the workflow.

Exploring Different Models and Options

1. Gen Kit supports various AI models and configurations. Explore the available options in the UI.
2. Customize the model settings to better suit your application's needs.

5 ANSHUMAN JHA
A Comprehensive Guide: AI-Agents Menu Suggestions with Genkit and Ollama

5. Building a Simple Application

Example Application and Its Functionality

We will build a menu suggestion application that uses a flow to generate themed restaurant menu
items. The application will use the Ollama model to process the input and generate suggestions.

Code Snippet Explanation

1. Setup and Configuration: Configure Gen Kit and Ollama, and define the workflow.
import { generate } from '@genkit-ai/ai';
import { configureGenkit } from '@genkit-ai/core';
import { defineFlow, startFlowsServer, runFlow } from '@genkit-ai/flow';
import * as z from 'zod';
import { ollama } from 'genkitx-ollama';

configureGenkit({
plugins: [
ollama({
models: [{ name: 'gemma' }],
serverAddress: 'http://127.0.0.1:11434',
}),
],
logLevel: 'debug',
enableTracingAndMetrics: true,
});

2. Defining the Flow: Create a flow to handle menu suggestions.

export const menuSuggestionFlow = defineFlow(
{
name: 'menuSuggestionFlow',
inputSchema: z.string(),
outputSchema: z.string(),
},
async (subject) => {
const llmResponse = await generate({
prompt: `Suggest an item for the menu of a ${subject} themed restaurant`,
model: 'ollama/gemma',
config: {
temperature: 1,
},
});

return llmResponse.text();
}
);

6 ANSHUMAN JHA
A Comprehensive Guide: AI-Agents Menu Suggestions with Genkit and Ollama

3. Running the Flow: Execute the flow with a specific input.

const response = runFlow(menuSuggestionFlow, 'French');

console.log(response);

4. Starting the Server: Start the flows server to handle requests.

startFlowsServer();

Modifying the Prompt and Testing Different Inputs

1. Change the prompt in the menuSuggestionFlow to test different themes.

prompt: `Suggest an item for the menu of a ${subject} themed restaurant`,

2. Run the application with different inputs to see varied results.

Running the Workflow within the Node.js Application

1. Build the application:

npm run build

2. Start the application:

npm run start

package.json
{
"main": "lib/index.js",
"scripts": {
"start": "node lib/index.js",
"build": "tsc",
"build:watch": "tsc --watch",
"test": "echo \"Error: no test specified\" && exit 1"
},
"name": "genkit-ollama",
"version": "1.0.0",
"author": "",
"license": "ISC",
"description": "",
"dependencies": {
"@genkit-ai/ai": "^0.5.1",
"@genkit-ai/core": "^0.5.1",
"@genkit-ai/dotprompt": "^0.5.1",
"@genkit-ai/flow": "^0.5.1",
"express": "^4.19.2",
"genkitx-ollama": "^0.5.1",
"zod": "^3.23.8"
},
"devDependencies": {
"typescript": "^5.4.5"
}
}

7 ANSHUMAN JHA
A Comprehensive Guide: AI-Agents Menu Suggestions with Genkit and Ollama

tsconfig.json
{
"compileOnSave": true,
"include": [
"src"
],
"compilerOptions": {
"module": "commonjs",
"noImplicitReturns": true,
"outDir": "lib",
"sourceMap": true,
"strict": true,
"target": "es2017",
"skipLibCheck": true,
"esModuleInterop": true
}
}

6. Debugging and Testing

Testing the Workflow Directly from the Terminal

1. Use the terminal to run the workflow and capture the output for debugging.
genkit flow:run menuSuggestionFlow '"French"'

Tips and Best Practices for Troubleshooting

1. Check the logs for any errors or warnings.

2. Use the trace feature in Gen Kit UI to identify issues in the workflow.
3. Ensure all dependencies are correctly installed and up-to-date.

8 ANSHUMAN JHA
A Comprehensive Guide: AI-Agents Menu Suggestions with Genkit and Ollama

7. Cloud architecture Diagram

In the realm of AI application development, Firebase Gen Kit offers a powerful toolkit for creating and
deploying sophisticated solutions. A notable example is an AI-powered application that suggests menu
items for themed restaurants. This project leverages Genkit and the Ollama AI model to provide creative
and diverse menu suggestions, enhancing the dining experience for restaurant customers.

The architecture of this solution is both robust and scalable, comprising the following key components:
1. User Interface (UI):
• Hosted on a web server or as a static site using cloud services such as AWS S3 or Firebase
Hosting.
• Facilitates user interaction with the application.
2. Node.js Application Server:
• Deployed on cloud platforms like AWS EC2, Google Cloud Compute Engine, or Azure VM.
• Manages the main application logic and processes requests from the UI.
3. Ollama AI Model:
• Operates on a local machine or a cloud VM.
• Utilizes the AI model (Gemma) to analyze input data and generate menu suggestions.
4. Genkit Server:
• Can be hosted alongside the Node.js server or on a separate instance.
• Handles the management and execution of workflows (flows) for generating menu
suggestions.
5. Optional Storage:
• A database (e.g., MongoDB, PostgreSQL) can be integrated to store configurations, logs,
and user data.
This architecture ensures a seamless flow of data from the UI through the Node.js server to the AI model
and back, providing efficient and innovative menu suggestions. By utilizing Genkit and Ollama, developers
can create powerful AI applications that enhance user experiences and streamline operational processes.

For those interested in building AI-powered applications, this example serves as an excellent starting
point. Detailed documentation and additional resources are available to guide developers through the
setup and implementation process.

9 ANSHUMAN JHA
A Comprehensive Guide: AI-Agents Menu Suggestions with Genkit and Ollama

8. Conclusion
Recap of Key Concepts and Steps
• Setup and configuration of the development environment.
• Exploration of Gen Kit UI and its functionalities.
• Building and running a simple AI application.
• Debugging and testing the workflow.

Encouragement to Explore Further

Experiment with different models, prompts, and configurations to create more advanced applications.
Leverage the power of Gen Kit and Ollama to build innovative AI solutions.

Additional Resources and Documentation

• Gen Kit Documentation
• Ollama Documentation
• Node.js Documentation

10 ANSHUMAN JHA
A Comprehensive Guide: Creating an AI-Powered Financial Analysis System

Constructive comments and feedback are welcomed

11 ANSHUMAN JHA