# Welcome to Gooey.AI Academy
Welcome to Gooey.AI Academy, learn and master the latest AI Workflows for Impact, Creativity and Productivity. Designed for product managers, impact professionals, and technical professionals. We offer step-by-step guides to AI Copilots and associated AI Workflows so you can build AI Solutions in days, not months!
### Featured Courses
# Using Gooey.AI Workspaces
{% embed url="" %}
Workspaces are very useful when working in teams. With workspaces, you can:
1. Collaborate on saved workflows
2. Access the [Version History](https://docs.gooey.ai/guides/how-to-use-workspaces/how-to-use-version-history) of saved workflows (with comments and the ability to revert to the previous version)
3. Share payment methods (so you can cover the Gooey usage cost for your team members)
4. Assign roles and access levels for team members
5. Shared API secrets (to securely access private APIs)
6. Manage multiple teams independently, each with their own billing details and saved workflows
If you are already added to a Workspace, you should be able to see it in the drop-down on the top right:
Tabs of Workspaces
* **Members** - view and adjust all your member invites and member rights
* **Saved** - view all your saved workflows here
* **API Keys** - save all your API keys here
## How to add team members?
If you are an Admin or an Owner you can add team members by clicking the Invite button in the [Manage Workspace>Members](https://gooey.ai/workspaces/members/) section.
**Learn more about Workspaces:**
# Intro to AI for Impact
{% embed url="" %}
Welcome! This guide will provide an overview of the core concepts behind building generative AI Agent using Gooey.AI, and outline the components and workflow involved in setting up, testing, and deploying your own AI assistant.
### What we'll cover:
* Understanding Large Language Models (LLMs)
* Introduction to Retrieval Augmented Generation (RAG)
* The Role of Vector Databases (VectorDB)
* Speech-to-Text and Text-to-Speech Overview
* Building and Deploying Your AI Agent
* Using Knowledge Bases and Tools
* Evaluation and Observability
***
### 1. Core Concepts
#### Large Language Models (LLMs)
LLMs, such as GPT-4, are AI models trained to generate natural language responses to user queries. They work by taking user input (e.g., “What is the capital of India?”) and generating an answer. However, LLMs can sometimes produce incorrect answers (hallucinations) if they lack relevant training data.
#### Retrieval Augmented Generation (RAG)
RAG enhances LLMs by integrating external knowledge sources:
* User queries are matched against an indexed knowledge base (documents, PDFs, web pages, etc.).
* Relevant snippets are retrieved and summarized by the LLM to form an accurate response.
* This is akin to an “open book exam,” allowing the AI to reference source material for answers.
#### Vector Databases (VectorDB)
A VectorDB indexes and stores document “embeddings”—numerical representations that map semantic similarity between pieces of text. For example, the word “bunny” is represented by its proximity to related concepts, allowing for smarter information retrieval.
***
### 2. Speech and Language Processing
* **Speech-to-Text:** Converts user audio inputs into transcribed text using models like Google Speech, Azure, Deepgram, Whisper (open source), or regional APIs like Bhashini.
* **Text-to-Speech:** Converts AI-generated text responses back into audio, allowing users to hear the answers.
* **Translation & Lip Sync:** Supports multilingual scenarios by translating answers and optionally generating video avatar responses.
***
### 3. AI Agent Interaction Flow
Typical flow for a AI Agent:
1. User submits a query (text, voice, or image).
2. AI Agent searches the knowledge base for relevant information (including conversation history, if applicable).
3. LLM synthesizes a response, optionally calling special functions/tools or APIs as needed (tool calling).
4. The answer is returned in text, audio, and/or video format, translated as required.
***
### 4. Tools, APIs, and Customization
* Choose appropriate models/APIs for each component (e.g., open source or commercial options for speech, embedding, translation, etc.).
* Configure tool calling for simple code-based functions or external API/database access, supporting “agentic” LLM behavior.
***
### 5. Deployment and Evaluation
* Deploy AI Agent via channels like web, WhatsApp, or IVR.
* Use built-in evaluation and observability tools to monitor AI Agent performance, ensure answer accuracy, and analyze user interactions.
***
### 6. Getting Started
To set up a AI Agent:
1. **Select language and speech models** for input processing.
2. **Upload and index your knowledge base** (documents, PDFs, CSVs, etc.).
3. **Configure your LLM and give it appropriate instructions**.
4. **Integrate tools/APIs** as needed for additional functionality.
5. **Set up output options** (text-to-speech, avatars, etc.).
6. **Deploy and monitor** your AI Agent through your chosen channels.
Throughout this documentation, you will find detailed modules explaining each step, with practical guides and demos to help you build, test, and refine your own generative AI Agent.
# How does Gooey.AI Agent Builder work?
{% embed url="" %}
* **Instructions**: Write your LLM Prompt here
* **Language Model**: Choose your Language Model here
* **Knowledge Base**: Add your expert knowledge documents here. These can be in PDF, Google Drive, Excel, Word Doc, OneDrive formats
* **Capabilities**: Enhance your AI Agent with Speech Recognition, Text-to-Speech, and Translation capabilities
* **Chatbot Preview**: Test your AI Agent in the Preview section
Other Tabs
* **Examples:** All published examples are here
* **API:** A pre-populated API code snippet for your AI Agent is here
* **History**: All runs for the AI Agent saved in your Workspace are here. These include all the test runs from the AI Agent Builder and API calls.
* **Saved**: All your saved AI Agent workflows are here; you have the option to make them private or public
* **Integrations:** Start deploying your AI Agent from the Deploy Tab
# Set your KPI and Metrics
Points to consider when building your KPIs
1. Collect a few clear set of assumptions from the Theory of Change model.
EG: For the Farmer.chat, a core KPI was: How have smallholder farmers' earnings improved after using the AI copilot?
2. Other KPIs could include:
3. Is the Copilot performing well, ie, its able to generate good answers
4. Is the Copilot successfully answering the questions (is it not answering at all)
5. What is the feedback you are getting from the user (just 👍and 👎)
6. What is the retention for the Copilot?
7. What are the topic-based differences?
8. What’s missing?
9. Language detection and rate keeping
10. Utilization of specific information
11. Outbound referrals to departments
12. Operators
# Bring Your Golden Q\&A
The Golden Q\&A pair helps to test
* Various prompt tweaks to improve the AI Agent's responses
* Compare LLM models
* Compare audio speech, recognition and, text-to-speech models
* Check price and latency
* Monitor regression
With the help of our Bulk and Evaluation Workflows, you can test the AI Agent quickly against a Q\&A set.
### Create your Golden Q\&A pair
Prepare your golden QnA set:
1. Create a list of the most frequently asked questions for your AI Agent (we recommend between 25 for optimum observability and regression you can do more if you prefer)
2. Make sure the Excel sheet/Google Sheets table has a “header” section
3. Add all your questions and golden answers in the column below it
> **An expert must provide the Golden Answers, these can't be synthetic answers.**
#### Common terms
* **Golden Answer**: Most suitable and accurate answers provided by humans with expertise on the subject
* **Semantic Closeness**: Since LLM will not output the same answer every time, the evaluation will check for how semantically close the output of the LLM is to your “Golden Answer”
* **Score and Rank**: For each generated answer the Evaluation workflow will give a “score” between 0 and 1, and rank the best answer.
* **Reasoning**: Evaluation LLM will share a short "reasoning" of how the score was given
* **Chart**: Based on the aggregate score, the Evaluation workflow will create a comparison chart
## KNOWLEDGE BASE VS GOLDEN Q\&A
| Knowledge Base | Golden Q\&A |
| --------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| The Knowledge base is this entire set of structured and unstructured data that encompasses your agent’s field of expertise. | Golden Q\&A is a sample set of questions and answers. This is sample set includes questions most likely asked by user with an answer most accurately framed by an expert in your team |
| This includes all your web pages, PDFs, CSVs, Docs, and videos. | This is always a table with 4-5 columns with “Questions” and “Answers” as separate column headers. |
| Exists in your AI Agent Builder | Is meant to be used in the Bulk Evaluation Workflow (we will learn about it in Session 4) |
| Is used directly in your citations for the AI Agent's answers | Is only meant for testing your AI Agent’s accuracy |
| Meant for answering external users questions | Meant for checking regression, quality, time and cost internally |
# Bring your Knowledge Base
{% embed url="" %}
## Steps to follow
* Bring specific documents about your Organisation or field of work
* Add it to the "Knowledge" section
* Test it on the AI Agent Builder with a relevant question from your Golden Q\&A set
### Tips and tricks
* If you have a Google Drive or OneDrive account, you can copy the link of the folder instead of pasting document links individually.
* If your documents are regularly updated, switch on the "Always Check for Updates" toggle.
* If your documents have a lot of diagrams and tables, it's advisable to use the "Create Synthetic Data" dropdown. This will extract your document page by page and provided extra synthesized data for every page, allow improved vector search.
# Setting up your LLM Prompt
{% embed url="" %}
## Basics of Prompt Instructions in Gooey.AI Agent
We'll use the example of creating a health bot that specializes in hypertension and blood pressure (BP), and we’ll walk through key prompting best practices.
### What is the “Instructions” Space?
The LLM prompt sets the foundation for your AI Agent's behavior. With the prompt you can:
* Define the AI Agent's role, scope
* How it should respond to users
* Tone of voice
{% hint style="success" %}
Well-written instructions ensure your AI Agent stays on topic and serves its purpose.
{% endhint %}
### Step 1: Open or Create Your AI Agent
Start by opening an existing AI Agent or creating a new one. For this example, we’ll use a template called **Clean Slate Copilot**. You can choose any of the AI Agent from our [Examples Tab](https://gooey.ai/copilot/examples/) select it from the examples list.
### Step 2: Define Your Bot’s Persona and Scope
We want to build a **health bot** that:
* Focuses strictly on hypertension and BP.
* Assists doctors and healthcare providers.
* Refuses to answer unrelated questions.
In the instructions box, write:
{% code overflow="wrap" %}
```
You are a health bot. You focus on conversations around hypertension and blood pressure (BP). You are an assistant to doctors and healthcare providers.
Do not answer questions that are not related to hypertension and BP. If a user asks you an unrelated question, you must reply: "I am sorry, I can’t answer this question. I am here to assist you with hypertension and BP topics."
```
{% endcode %}
### Step 3: Add a Friendly Greeting
A welcoming tone encourages user engagement. Add to your instructions:
{% code overflow="wrap" %}
```
If a user greets you (for example, says "hi"), reply: "Hi, I'm HelpBot. I specialize in hypertension and BP education. How can I help you today?"
```
{% endcode %}
### Step 4: Testing Your AI Agent
Let’s verify that your AI Agent follows the instructions. We will ask two questions:
1. Related to the Knowledge Base and the purpose of the AI Agent
2. Unrelated to the Knowledge Base and AI Agent's purpose
Try asking it an unrelated question, such as:
> What is the weather like in Udaipur in the summer?
You should see a response like:
> I am sorry, I can’t answer this question. I am here to assist you with hypertension and BP topics.
This confirms your bot is following its assigned scope.
### Why is This Important?
Clear instructions ensure your AI Agent stays focused, improving reliability, user trust, and the overall experience. For specialized domains like healthcare, it’s essential to avoid accidental misinformation by only handling relevant queries.
# Jinja Templating
## Variables
When deploying an AI Agent, your API calls will typically consist of two types of content:
* **Fixed content** Static instructions or context that remain constant across multiple interactions
* **Variable content:** Dynamic elements that change with each request or conversation, such as:
* User inputs
* Retrieved content for Retrieval-Augmented Generation (RAG)
* Conversation context such as user account history
* System-generated data such as tool use results fed in from other independent calls to Claude
The variable content is denoted with **`{{double brackets}}`**, making them easily identifiable and allowing for quick testing of different values.
In the example below, there is a JSON object with a `title` and `pageContent` that is passed to the LLM Prompt
{% code title="AI Prompt" overflow="wrap" %}
```
{% if pageJSON %}
# Inputs
pageJSON: {{ pageJSON }}
By default, assume that the subject of enquiry is {{ pageJSON.title }}.
{% endif %}
```
{% endcode %}
{% code title="JSON Object as a Variable {{ pageJSON }}" %}
```json
{
"title": "Deploy to WhatsApp",
"pageContent": "\n\n\n \n Deploy to WhatsApp\n\n\n
\n NOTE: Gooey connects to a Facebook profile, not a Facebook Page. If you don\u2019t have access to the organization\u2019s Facebook profile, create a dedicated one.\n
\n\n \n
Step 1: Fill Business Information
\n
Step 2: Choose your business account (or create a new one)
\n
Step 3: Add a phone number for your WhatsApp bot
\n
Step 4: Verify the phone number
\n \n\n
YOUR BOT IS NOW READY!
\n\n
Test
\n
You can test your bot by heading to the registered number!
Q: I have got a new number for the WhatsApp integration but it isn't working. What should I do?
\n
A: Avoid these mistakes:
\n
\n
Activating the SIM on a smartphone with WhatsApp
\n
Registering the phone number directly on Facebook
\n
Registering the phone number on WhatsApp Manager
\n
\n
You\u2019ll need to deactivate these before integrating with Gooey Copilot.
\n\n
Q: The integration worked successfully, but it's not working now. Why is this?
\n
A: After integration, do not use the number with a WhatsApp client. That breaks the bot integration.
\n\n
Q: The integration worked successfully, why did the bot stop working after the first day?
\n
A: Facebook requires a credit card on file to keep the number active. Even if they don\u2019t charge anything, it\u2019s necessary to pass their verification process.
\n\n"
}
```
{% endcode %}
{% embed url="" %}
See the Example here
{% endembed %}
## Conditional statements
It is a common use-case that the same AI Agent example might be deployed/integrated on various platforms like SLACK, WHATSAPP, WEB and so on. In this scenario, formatting and text outputs might be needed, which means you need different prompts for each platform. With Jinja Templating, this issue is solved. You can use the prompt example below and tweak it as needed:
{% code title="if statement in prompts" overflow="wrap" %}
```
{% if platform in [ "WHATSAPP", "SLACK" ] %}
Remember, you are a {{ platform }} agent, so do not use HTML, latex or any other markup language, instead use only the following formatting styles:
italic: single underscore
bold: single asterix. Do not use 2 asterix as per markdown, instead use {{ platform }} guidelines and use 1 asterix only
strikethrough: single tilde
code: single backtick
code block: 3 backticks
quoted text: place an angle bracket and space before the text
headings: just use bold style with 1 asterix.
{% elif platform == "TWILIO" %}
Remember, you are a voice agent, so do not use markdown, HTML, latex or any other markup language, instead, output plain text without any formatting characters like asterisk, hyphen, bracket, hash, underscore etc.
{% endif %}
```
{% endcode %}
{% embed url="" %}
# Few shot instructions
In some scenarios, adding a few example conversations in the prompt is advisable to improve the outputs - this is called Few-Shot Prompting. This is useful when:
* The answers are too verbose, and you want to shorten the responses
* You want to ensure the answer is always the same with no changes
After adding the main prompt, you can add a few-shot examples, which reflect the kind of responses you want from the AI Agent, these could be useful to limit the answers to a certain length, maintain a brand-related tone, etc.
{% code overflow="wrap" %}
```
--- insert your project-relevant prompt above this line ---
User: Give an accurate summary in ~100 words only to my questions.
Assistant: Surely
User: Do you have a lipsync tool?
Assistant: Yes, Gooey.AI does have a Lipsync tool. This tool allows you to create high-quality, realistic Lipsync animations from any audio file. Here is the link to the tool: https://gooey.ai/Lipsync/ and here is the guide: https://gooey.ai/docs. Can I help with you with anything else?
User: How can i book a demo?
Assitant: To book a demo with Gooey.AI, you can visit: https://www.help.gooey.ai/contact#book-demo
```
{% endcode %}
{% embed url="" %}
See the full example here
# Tips for prompting based on LLM
| Feature / Style | OpenAI (GPT-4, GPT-3.5) | LLaMA (LLaMA 2 & 3) | Mistral (Mistral 7B, Mixtral) |
| ------------------------------- | ---------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
| **Role Structure** | Uses `system`, `user`, and `assistant` roles explicitly | No native role handling, but you can simulate it using text cues | No role handling, but follows text cues and prompt templates |
| **System Prompt Support** | ✅ Full support — allows defining model behavior (e.g., `"You are a helpful assistant."`) | 🚫 No native support; must embed in user prompt manually | 🚫 No native support; simulate via prompt prefix |
| **Formatting Style** | Natural conversation, JSON-compatible, markdown-friendly | Structured, requires consistent formatting for few-shot and instruct modes | Concise and direct; works well with bullet lists, steps, or templates |
| **Few-shot Learning** | Highly effective with few-shot examples | Effective, especially with CodeLLaMA and LLaMA-Instruct variants | Can benefit from few-shot, though prefers minimal examples |
| **Chain-of-Thought Reasoning** | Strong performance with "Let's think step by step" style prompts | Improves performance significantly with explicit CoT instructions | Supports CoT well, especially in instruct-tuned variants |
| **Prompt Length Handling** | Handles long prompts well (especially GPT-4-1 with large context windows) | Medium capacity; recent models like LLaMA 3 support longer prompts | Smaller context (e.g., 32K tokens), favors concise prompts |
| **Fine-tuning Response Format** | Easily aligns to JSON, tables, and multi-part instructions | Needs more specificity to get consistent formatting | Consistent if given strict format constraints |
| **Use of Delimiters** | Often uses `"""` or `###` to separate instructions from input | Suggested to separate examples and instructions clearly | Benefits from template-like structures, including consistent line breaks |
| **Multimodal Input Handling** | GPT-4o supports images and audio | LLaMA 3 (future) may add modalities; current LLaMA is text-only | Mistral is text-only for now |
# Adding Language and translation
{% embed url="" %}
### **Add Speech Recognition and Translation**
This guide explains how to enable speech recognition and translation in your GUI AI-powered AI Agent, using the example of a hypertension health assistant. These features are especially useful for building multilingual bots—like an agriculture assistant for Northern India, where Hindi is widely spoken. With these capabilities, users can send voice notes in their preferred language and receive answers in the same language.
#### **Enabling Speech Recognition**
* In the Capabilities section, enable the **Speech Recognition** feature. This allows users to record voice messages directly into the AI Agent.
### Test
Click the microphone/clip icon in the message section, record a question (e.g., “What is your recommendation for drug classes as first-line agents?”), and click on "Send".
* The LLM processes the transcribed text and generates a response, referencing the knowledge base (e.g., the WHO hypertension guidelines).
### Adding T**ranslation**
Many LLMs may not fully understand non-English languages, so translation is essential to any AI Agent pipeline.
Steps to follow:
* To support other languages (e.g., Hindi), enable the **Translation** feature alongside speech recognition.
* Select your translation provider (e.g., Google Translate).
* Set the target translation language (e.g., Hindi).
* Now, when a user submits a voice note in their preferred language, the system will:
* Transcribe the audio
* Translate the input to English for the LLM (if needed)
* Process the question
* Translate the LLM’s response back into the user’s language (e.g., Hindi)
### **Next Steps**
* In the next guide, you’ll learn how to add **Text-to-Speech**, allowing users to listen to responses in their language instead of reading.
# Setup Text-to-Speech
{% embed url="" %}
### Enable Text-to-Speech
Enable Text to Speech in the "Capabilities" section
### Test
Follow the steps from the previous section on [Adding Language and Translation](/ai-for-impact/module-6) to send a voice note to the Copilot. Once the Text-to-Speech Capabilities are enabled, you will observe that your text response has a small Audio Player.
# Deploy Your First Web AI Agent
{% embed url="" %}
**SET UP INTEGRATION CONFIG**
1. Click on the Integrations tab
2. Use the “Gooey.AI” button
1. This will open the Web widget configuration page. You can add the following details:
1. Name of the bot
2. Description - this will be the introduction of the bot
3. By line and website link
4. Conversation Starters - add some introductory questions for the users
1. Hit Update
2. Test your bot here:
1. Click on the “Message the bot” button and test the bot.
**EMBED TO WEBSITE**
Once you are happy with the performance of the tests, you can Embed the bot in your production website with just two lines of code.
# Your first evals!
### What is a Golden Q\&A?
A Golden Q\&A is a list of common questions and accurate answers, created by experts on your team. These are used to test your AI Agent's performance.
### Bulk Evaluation Process (Overview)
* The Golden Q\&A sheet is used as the test set in the [bulk evaluator](https://gooey.ai/bulk).
* For each question, the AI Agent generates an answer.
* The evaluator compares the AI Agent answer to the expert (golden) answer.
* Scores are based on technical accuracy, citation correctness, and answer quality.
## Why is bulk run and evaluation important?
Bulk runs and evaluations help you with:
* Choosing the right
* LLM
* TTS
* STT
* Translations
* Improving your overall AI Agent's responses
* Assess time vs cost for the choice of the pipeline
* Check regressions regularly
### Why do you need a bulk runner and evaluations?
When building your Gooey.AI workflows, you will have to tweak the settings often to ensure the responses show parity and are grounded and verifiable.
**There are several components to test:**
* testing prompts
* ensuring the synthetic data retrieval works
* checking the suitability of the language model and its advanced settings
* Latency of generated answers
* evaluation of the final AI Agent to produce the Golden Answers
* evaluation of the price per run
* regression tests
How can you do this at scale?
**This is where Gooey.AI’s Bulk and Evaluation features shine!**
### Features of Bulk Runner and Evaluation
* Run several models in one click
* Run several iterations of your workflows at scale
* Choose any of the API Response Outputs to populate your test
* Get output in CSV for further data analysis
* Built-in evaluation tool for quick analysis
* Use CSV or Google Sheets as input
# How to prepare your Golden Q\&A
### Checklist Before the Session
* [x] Prepare 10–20 typical user questions
* [x] Write expert answers for each
* [x] Add citation links or references for every answer
* [x] Organize everything in a Google Sheet/CSV (add Audio column if needed)
{% embed url="" %}
## How to Prepare Your Golden Q\&A for Evaluating Your AI Agent
This document explains how to prepare your Golden Q\&A for use with Gooey.AI’s bulk evaluator. Follow each step to ensure your AI Agent can be tested and improved effectively.
### 1. Gather Typical User Questions
* Identify 10 to 20 common questions users might ask your AI Agent.
* These should cover important topics and key use cases.
### 2. Write Expert Answers
* Write the most accurate answer for each question you would want your AI Agent to give.
* Subject matter experts or your product team should write answers.
### 3. Add Citations
* For every answer, include a citation.
* The citation is a link or reference to the source material (webpage, PDF, document, knowledge base).
* If citing a PDF or document, include the page number or section.
### 4. Use Google Sheets for Organization
* Create a Google Sheet with the following columns:
* Question
* Answer
* Citation (URL, document link, or specific page/section)
* If you are evaluating audio (user voice notes), add an “Audio” column. Place the Google Drive link to the audio recording for that question.
### 5. Example Google Sheet Format
| Audio (if needed) | Question | Golden Answer | Citation |
| -------------------------- | ------------------------------- | ---------------------------- | ------------------- |
| \[Google Drive audio link] | What is the lip sync tools API? | The lip sync tools API is... | \[Link to API docs] |
| \[Google Drive audio link] | How do I animate a character? | To animate a character... | \[Link to tutorial] |
**You can duplicate this** [**Google Sheet**](https://docs.google.com/spreadsheets/d/1yw5VFASGUehz0vdhHIVvPgTh3xRXuubfqaDWAkG0ZAM/edit?usp=sharing)
### **Learn more about Speech Recognition Evals here:**
{% embed url="" %}
# How to use bulk runner?
{% embed url="" %}
**1. Prepare Your Test Questions and Golden Answers**
* Create a spreadsheet with your test questions and golden answers.
* Your sheet should have columns for:
* question
* golden answer
* citation (if needed)
* audio file as a Google Drive link if needed
**2. Create or Duplicate Your AI Agent**
* You need a AI Agent for each model or prompt you want to test.
* To create a new AI Agent for a different model (for example, to test Gemini 2.5 Pro vs. GPT 4.1):
* Go to your existing AI Agent, click "Update," then "Save as new" to duplicate it.
* Choose the new model (such as Gemini 2.5).
* Update the name (for example, "Gemini 2.5").
* Click "Save".
**3. Set Up the Bulk Run**
* Go to [gooey.ai/bulk](https://gooey.ai/bulk).
* Link your spreadsheet containing the test questions and golden answers:
* In the "Input data spreadsheet" section, click "Link" and paste your spreadsheet URL.
* Click "Import."
* Once imported, check that your questions and golden answers have loaded correctly.
**4. Add Your AI Agents as Workflows**
* In the bulk runner, click "Add workflow."
* Start typing the name of your AI Agent (for example, "marketing\_gooey\_support\_bot") and select it.
* Add each AI Agent you want to compare (for example, one for GPT 4.0, one for Gemini 2.5 Pro).
**5. Configure the Input and Output Columns**
* Go to "Show all columns."
* Set "Input prompt" to your question column (e.g., "question").
* Make sure "Output text," "Run URL," and "Runtime" are checked. They help you with results and debugging.
**6. Enable Evaluation Workflow**
* In the "Evaluation workflows" section, enable "Copilot evaluator."
* This will compare each model's output to your golden answer and score them.
{% hint style="info" %}
If you only want to run the bulk runner without evaluation, you can delete the evaluator.
{% endhint %}
**7. Start the Bulk Run**
* Click "Run."
* Gooey.AI will process each question through every selected Copilot/model.
* For each question and Copilot, you get the generated answer, run URL, runtime, and more.
**8. Review and Compare Results**
* In the results sheet:
* Each row shows the question, the answer from each Copilot, the runtime, and the run URL.
* At the end, you will see the evaluation scores for each model.
* The system identifies which model performed the best for each question and overall.
**9. Analyze Performance**
* Look at the evaluation scores (for example, 80%, 100%, 60%).
* Higher scores mean answers closer to the expert-provided golden answer.
* If a new model scores lower, review the answers and ratings to find areas for improvement.
**10. Repeat or Refine**
* You can rerun the evaluation after adjusting prompts, models, or questions.
* Use the results to decide which model or prompt is best for your use case.
### How to add Audio Input in Bulk Evaluations?
{% embed url="" %}
# How to use evaluation?
{% embed url="" %}
# Iterate!
{% embed url="" %}
# Agentic LLMs, Functions and Developer Tools
Functions allow you to run sandboxed Javascript functions & API calls inside your Gooey.AI workflows.
{% @mermaid/diagram content="---
title: POSSIBILITIES FOR FUNCTIONS
----------------------------------
graph TD
```
subgraph AI Agent
A[User asks a Query] ==> B(AI Agent's RESPONDS)
B ==> C[Response sent to User]
end
D(BEFORE Request to Gooey Workflow)-..->B
G[(Database)] <--> D
B -..->E(AFTER Request to Gooey Workflow)
E <-->H[(Database)]
```
style A fill:#f9f
style C fill:#f9f
style G fill:#39f
style H fill:#39f" %}
### Example of AFTER Function:
{% @mermaid/diagram content="---
title: AFTER FUNCTION FOR ANALYSIS SCRIPT
-----------------------------------------
flowchart TD
A\[User asks a Query] --> B\[AI Agent RESPONDS]
B --> D\[Response sent to User]
D --> |response collected|E{Analysis Script}
A --> |query collected|E
E --> |user needs human handoff|F(AFTER FUNCTION ACTIVATED)
E --> |user was satifised with answer|G\[CHAT LOOP CLOSED]
F --> |user query and contact pushed to CRM|H\[CRM]
" %}
## How do LLM-enabled Functions work?
When the user sends a query in Natural Language, the LLM determines the following:
1. does the query require a function?
2. which part of the text should be passed as an argument in the function?
{% @mermaid/diagram content="graph TD
A\[User asks a query] --> B{LLM assess if functions are needed}
C\[LLM responds with function arguments] -->D\[Function is called with arguments]
B --> |Functions needed|C
B --> |Functions not needed|J\[LLM Responds with answer]
D --> E\[Function executes]
E --> F\[Function returns result]
F --> G\[LLM processes function result]
G --> H\[LLM formulates final response]
G --> B
H --> I\[Response sent to user]
J --> I
" %}
# How to use Functions?
### **Step 1**
Head over to the [Functions workflow](https://gooey.ai/functions/)
### **Step 2**
Create your PROMPT Function:
* create a basic fetch call for the weather of any location
* create a serper
**You can find more** [**examples here**](https://gooey.ai/functions/examples)
#### A basic Weather API call ([link here](https://gooey.ai/functions/current-weather-rxmquy60p1vq/))
```javascript
async ({ lat, long }) => {
// Use Open-Meteo's public API for fetching weather data
let url = `https://api.open-meteo.com/v1/forecast?latitude=${lat}&longitude=${long}¤t_weather=true`;
let response = await fetch(url);
let data = await response.json();
return { weather: data.current_weather };
};
```
#### An API call for Serper - a service for google search ([link here](https://gooey.ai/functions/google-search-without-api-key-tey6zrx2vzvm/))
```javascript
async ({ query }) => {
var myHeaders = new Headers();
myHeaders.append("X-API-KEY", "your API key");
myHeaders.append("Content-Type", "application/json");
var raw = JSON.stringify({
"q": query
});
var requestOptions = {
method: 'POST',
headers: myHeaders,
body: raw,
redirect: 'follow'
};
let ret = await fetch("https://google.serper.dev/search", requestOptions);
return { search_results: await ret.json() };
};
```
### **Step 3**
Hit Submit, if your code is working fine you will get your outputs on the right side. Use the “Save as New” button and update the run name.
### **Step 4**
Now head over to the Gooey workflow where you want to add the saved functions.
Head over to the example below:
{% embed url="" %}
Check the Functions option, and choose “PROMPT” from the dropdown and add your Saved example. And then hit "SUBMIT!
*You can check your Functions output in the Workflow at the end of the page in "Details" section.*
# Adding Functions for Value-Adds
### Google Search
### Weather
# Adding Functions for Data
You can use custom REST APIs and JS Functions through the Functions sandbox.
# Deploy on WhatsApp
**Prerequisites**
* Verified Facebook business account
* A new or spare phone number for the WhatsApp bot
**Integration**
Click on the [Deploy tab](< https://gooey.ai/copilot/integrations/>) in the AI Agent workflow
* Use the “WhatsApp” button
* You’ll be redirected to the Facebook Login Page
> NOTE: Gooey connects to a Facebook profile, it will not connect to a Facebook Page. If you don't have access to the Facebook profile/account of your organization, we suggest making a special Facebook profile for this.
* Follow the instructions on the Facebook page
### Step 1 - Fill in Business Information
### Step 2 - Choose your business account (or create a new one)
### Step 3 - Add a phone number for your WhatsApp bot
### Step 4 - Verify the phone number
### **YOUR BOT IS NOW READY!**
**Test**
You can test your bot by heading to the registered number!
**Share**
To share the link with others, share the number like this: \
#### Your AI Agent is ready for the world! 😀
### Frequently Asked Questions
**Q: I have got a new number for the WhatsApp integration but it isn't working. What should I do?**
A: There could be a few reasons why this isn't working, please AVOID these steps:
* You have activated the sim card on a smartphone with WhatsApp messaging app
* You have registered the phone number directly on Facebook
* You have registered the phone number directly on Whatsapp Manager
Please avoid this, you will not be able to integrate Gooey Copilot on that number until you deactivate all these things.
**Q: The integration worked successfully, but it's not working now. Why is this?**
A: We have commonly found that after successful integration users/organizations try to use the connected phone number on the WhatsApp client for messages sent by human experts. Once you have integrated the WhatsApp bot with your AI Copilot, you can't have additional human-sent messages like other WhatsApp Business Accounts.
**Q: The integration worked successfully, why did the bot stop working after the first day?**
A: If you don't connect a credit card to your Facebook Account for the bot, it will deactivate in 24 hours. There won't be any additional charge from Facebook but they require a credit card to activate the account. Once you add a card there will be a business verification process.
# Adding Buttons
Adding buttons for WhatsApp and Web Widget
## TOS
{% code overflow="wrap" %}
```
Please tap 'I agree' to let us know you understand what data we collect and to ask any farming related question.
```
{% endcode %}
## Location
{% code overflow="wrap" %}
```
If the user asks something related to their current location, ask them for their location first by displaying the following html button:
Explain your need for the location and comfort the user in knowing that their location wont be shared publicly as a binding legal agreement. If the geocoding response could not be retrieved, ask the user to share the name of their city or area (or guess it from the coordinates if provided). Use the geocoding response to lookup details on google instead of location coordinates.
```
{% endcode %}
## **Create contextual questions for follow-on conversations**
```
After your response, display upto 3 likely user responses or follow-up question as HTML buttons. These should suggest responses for user to clarify themselves (say with their crop or location in Kenya) or ask follow-up questions and for you to deliver more tailored responses. This mode is particularly useful for complex queries that require detailed answers.
First display the questions to the user as plain text (with an appropriate emoji in front)
{emoji1}: {question1}
{emoji2}: {question2}
{emoji3}: {question3}
Then render quick buttons as HTML elements like so:
```
1. Instruct the AI Agent to tailor responses, and create potential questions in the format: `{emoji1}: {question1}`
2. And further prompt the AI Agent to create `
.png?alt=media&token=188f37cc-cc43-43f0-b930-e18be63fd8d2)
.png?alt=media&token=08c0635f-4271-441a-842f-b02354130276)
.png?alt=media&token=0b5f44d1-501f-4b5c-8742-9fa323e66220)
.png?alt=media&token=f441a3b7-36e4-48bc-871d-aa466e31319c){kind=link}
.png?alt=media&token=e4b9271b-5695-4e24-8f0d-50a6cc01ab47){kind=link}
