Introduction
In recent years, we’ve seen significant advancements in Large Language Models (LLMs), including improvements in model size, accuracy, and contextual comprehension across various domains. Built on the architecture of Generative Pre-trained Transformers (GPT), these models have enhanced data generation capabilities and a broad range of domain applications. While LLMs have shown impressive intelligence, they still come with limitations, such as hallucinations (producing incorrect or fabricated responses) and an inability to handle proprietary or personal data without additional integration.
To address these limitations, systems like Retrieval-Augmented Generation (RAG) have been developed and gaining widespread adoption across industries. These systems enhance the LLMs’ ability to work with proprietary data, and there has been ongoing work to optimize and refine these workflows. Known as compound AI systems, they offer benefits like modularity and ease of adaptability. However, they still face challenges when handling complex queries that need to be broken down into sub-queries and then combined to deliver a final answer. Typically, these systems rely on a fixed, programmatically defined control logic created by humans. While this setup allows for speed, it also introduces rigidity, making it difficult to solve more complex queries effectively.
This has led to the emergence of workflows where an LLM serves as the central element in the control logic, dynamically deciding the next steps based on interim outputs. Such control logic, where the LLM drives the process, may be slower but tends to be more accurate in delivering final results. These workflows are often referred to as “agents.”
Now, let’s take a step back from the technical talk. Imagine if your personal AI assistant could help plan your meals, taking into account your diet preferences, budget, and nutritional goals. That’s exactly what we will build, our personalized Meal Planner Agent along with understanding each concept in detail. Using AI agent workflows, it fetches your dietary requirements, suggests a grocery list within budget, and crafts a well-balanced meal plan—all dynamically decided by the AI itself.
What are AI agents?
Imagine having an intelligent assistant that doesn’t just follow a rigid script but actively thinks, adapts, and problem-solves in real time. That’s the essence of AI agents. Unlike traditional systems with fixed logic, AI agents leverage LLMs to reason, plan, observe, and act. They don’t just execute predefined rules—they dynamically decide the next steps by interpreting real-time data and external inputs.
These agents integrate multiple tools, access various data sources, and execute external functions to complete tasks effectively. This flexibility makes them ideal for handling complex queries, adapting to new information, and automating workflows that would otherwise require human intervention.
At their core, AI agents operate in a structured yet adaptable workflow:
User Input: The process begins with a query or task request.
Decision-Making: The LLM processes the input, breaking it into manageable subtasks, if necessary.
Tool Integration: The agent interacts with APIs, databases, or external tools to gather relevant data.
Evaluation: It analyzes interim outputs and determines the next best action.
Final Response: Once all necessary steps are completed, the agent delivers a well-structured, accurate response.
This ability to reason, iterate, and optimize decisions dynamically makes AI agents a game-changer across industries—from customer support chatbots to AI-driven research assistants and even intelligent meal planners.
Why AI Agents?
The rise of AI agents is driven by the need for more intelligent, adaptable systems that go beyond the static capabilities of traditional LLMs. While LLMs are powerful, they are inherently limited to the knowledge available at the time of their training. This means they struggle with real-world tasks that require up-to-date information, multi-step reasoning, or interaction with external data sources.
Real-world problems are rarely solved with a single, pre-learned response—they often demand planning, contextual awareness, tool usage, and iterative decision-making. Simply training larger models doesn’t guarantee they will consistently deliver accurate or relevant responses, especially when handling ambiguous or multi-step queries.
This is where AI agents come in. They enhance LLMs by:
1. Using real-time data instead of relying only on pre-trained knowledge
2. Breaking down complex tasks into smaller, logical steps for better accuracy
3. Interacting with external tools to fetch fresh insights, perform actions, or automate workflows
4. Reducing hallucinations by grounding responses in reliable data sources
For example, consider a meal planner agent that helps you plan your meals. A static LLM might provide general advice, but an AI agent can retrieve the user’s food preferences, body type, and budget and create personalized meals based on user goals.
By combining LLMs with structured reasoning, external integrations, and iterative problem-solving, AI agents bridge the gap between raw intelligence and real-world usability.
While AI agents offer a more adaptable approach, their effectiveness depends on several core components that enable reasoning, planning, and decision-making. Let’s break down these essential elements.
Critical Components of an Agent
Agent Core
At the heart of an AI agent is the LLM), which drives all key decisions and behaviours. The LLM, trained on vast datasets, encodes generalized knowledge in its weights and biases, enabling it to reason about various topics and infer appropriate responses. Within the agent core, different modules are integrated, with the LLM using structured prompts to coordinate the workflow. Depending on the specific use case, the prompt may incorporate several essential components.
def get_prompt():
return PromptTemplate(template="""Answer the following questions as best you can. You have access to the following tools:
{tools}
Use the following format:
Question: the input question you must answer
Thought: you should always think about what to do. Never assume action inputs, either fetch from other tools or ask user.
Action: the action to take, should be one of [{tool_names}]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question
Begin!
Question: {input}
Thought:{agent_scratchpad}""")Let’s first focus on the several components added as inputs in the prompt.
Question: The actual question asked or instruction given by the end user.
Example: Create a personalized meal plan for user id 1
Tools: The list of external tools, e.g., APIs, database, specific processing functions. We will talk about these tools in detail later
Agent Scratchpad: A workspace where the agent records intermediate thoughts, actions, and observations. It helps to maintain a stateful, step-by-step reasoning process.
We are using a ReAct prompt above, a React Prompt typically refers to a structured instruction given to an LLM guiding how the LLM should process user queries and interact with external tools. It helps the LLM understand context, decide actions, and generate responses systematically.
You don’t have to understand the prompt now, we will look at an example later to see how this structured prompt works. Before that let us cover the other essential parts.
Planning
For an agent to execute a task effectively, it needs to create a detailed plan, similar to achieving the goal of creating a nutritious meal. For instance, creating a meal plan requires a clear sequence of actions:
Selecting if the meal is for breakfast, lunch or dinner
Identifying user’s fitness goals, for example weight loss
Checking budget availability
Choosing a set of ingredients
Deciding the dish that needs to be prepared
Creating a detailed recipe for the planned dish
Similarly, AI agents use reasoning to break down complex tasks into subtasks. Advanced planning techniques involve self-reflection, where the agent reviews and refines its strategy before execution. A simple yet effective prompting technique, such as “What are the necessary steps to complete X?”, enables agents to develop an initial plan and critically assess it for missing details. Some agents even employ multi-step reasoning to adjust their approach dynamically as new information emerges.
Memory
Executing a series of tasks, such as choosing a set of ingredients for the meal, requires a balance between short-term and long-term memory:
Short-Term Memory: This involves retaining immediate tasks and subtasks, ensuring actions are relevant to the current context. The LLM follows instructions provided in its prompt, which are held in memory during the task but discarded once completed.
Example: the agent scratchpad is used to record intermediate thoughts, actions, and observations in the prompt thus remembering the sequence of steps done till now.
Long-Term Memory: This allows the agent to retain critical information over longer interactions or task executions. For example, remembering which ingredients are preferred by the end user to not end up creating a meal the user dislikes. Since most LLMs lack built-in long-term memory, this is typically achieved by maintaining an external database that stores contextual information and past interactions. The input prompt is then augmented with relevant long-term data.
Tools
While LLMs can process and generate information, they cannot independently interact with external systems or access real-time data. To overcome this, agents are equipped with a set of tools tailored to the specific use case. These tools help the LLM perform actions, retrieve new information, and expand its capabilities beyond its training data.
For example, an LLM agent creating a meal plan may use:
User Database: To access the user’s goal, ingredient preferences, etc.
Budgeting Software: To track expenses and manage the budget.
E-commerce Order Executor: To buy groceries
The key advantage of AI agents lies in their ability not only to call upon these tools but also to identify the most appropriate one for the task at hand. Just as a surgeon is not merely defined by access to surgical instruments but by the knowledge and expertise to use them effectively, an LLM agent’s effectiveness comes from its ability to reason, plan, and execute tasks by selecting and using the right tools strategically.
For our meal planner agent, we will define 3 simple tools,
Get user’s preferences and health goals
@tool def get_user_preferences(user_id: int) -> str: """Fetches the user's dietary preferences and health goals.""" return "diet: keto, health goal: weight loss, preferred ingredients: avocado, chicken, spinach, budget: 1500 rupees "
Given a user ID the above tool returns the user’s preferred diet, health goal, ingredients and budget.
For ease of understanding, we have simply returned a hardcoded string with all the information. You can easily replace this with a database lookup and you have a dynamic tool at hand that fetches all this information for a given user.
Important Components of a Tool
a. Meaningful tool name
The tool name should align with the task it accomplishes. The tool name is sent to the LLM via the prompt as seen above and is one of the components using which the LLM makes decisions. If a given tool can help to accomplish an identified subtask the tool name will be given as the output by the LLM. For example, if the subtask identified by the LLM is to get user preferences the LLM will choose the above tool and return it as the output.
b. Parameters required
Each tool can take 0 or more parameters as input. The parameter name should be descriptive enough for the LLM to understand what needs to be passed. Based on the task at hand LLM extracts information from the context that is given as the parameter value in the output. For example when the get_user_preferences tool is identified the LLM also extracts the user ID from the context and appends it in the output
c. Well-defined tool description
Similar to the tool name and parameters the tool description needs to be clear and should precisely describe the capability of the tool. Better the description better the LLM will be able to choose the right tool for a given task. Langchain uses the docstring of the function as the tool description.
d. Tool decorator
Finally to register a function as a tool the @tool decorator need to be added on top of the function. Depending on the framework being used this will vary.
Grocery list creator
@tool def get_grocery_list(inputs: str) -> str: """Suggests a grocery list based on diet and budget. inputs: {"diet": "user's diet type", "budget": "budget with currency", "preferred_ingredients": "list of preferred ingredients"}""" input = json.loads(inputs) system_message = SystemMessage( content=f"""Create a personalized grocery list for a {input['diet']} diet. The user preferences includes: {input['preferred_ingredients']}. Consider other similar items that the user would like. Keep the budget under: {input['budget']}. Consider items and quantity for a week. Do not add any meal details.""") return llm.invoke([system_message]).content
Given the user’s diet choice, budget available and preferred ingredients this tool returns a list of grocery items that would be required to create a meal plan. To create the grocery list an LLM call is made along with a prompt instructing the same. As seen in the prompt we have instructed the LLM to consider quantity of items for a week. Here we chose to make an LLM call inside the tool however it can be as simple as a DB lookup returning a list of grocery items as well.
You might have already noticed that the tool description contains a JSON schema definition. The LLM will look at this JSON schema and create a string in the same structure that can be then passed to the inputs string parameter in the get_grocery_list function. In this use case we are leveraging a langchain react agent component that we will see further and its capability is limited to having tools that accept a single parameter. Thus in order to get around that limitation we are using a structured JSON schema as input.
Final meal plan generator
@tool def get_meal_plan(inputs: str) -> str: """Creates a structured meal plan based on: All input parameters are mandatory: inputs: {"diet": "user's diet type", "health_goal": "user's health goals", "grocery_list": "suggested grocery list"}""" input = json.loads(inputs) system_message = SystemMessage(content=f"""Create a personalized meal plan for a {input['diet']} diet with a goal of {input['health_goal']}. The grocery list includes: {input['grocery_list']}. Keep the meal plan structured and simple.""") return llm.invoke([system_message]).content
We bring together all the information we have till this point i.e. the users diet preference, health goal and the grocery list to create the meal plan. Similar to the earlier tool we are have defined a JSON schema in the tool description to allow multiple data points to be passed to the tool as input. Once we have the inputs we are making an LLM call with a clear prompt to generate the structured meal plan.
Bringing it All Together
Now that we’ve explored the core components of an AI agent—reasoning, planning, memory, and tool integration—let’s put everything into action. Below is the code that brings together all the moving parts we’ve discussed and executes the personalized meal planning agent end to end.
def start():
user_question = "Create a personalized meal plan for user id 1"
tools = get_tools()
react_prompt = get_prompt()
agent = create_react_agent(llm=llm, tools=tools, prompt=react_prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True,
handle_parsing_errors=True)
result = agent_executor.invoke(input={"input": user_question})
print(result)How It Works
User Query Initiation
The process starts with a user query: “Create a personalized meal plan for user id 1.” This input sets the entire workflow into motion. The user query can be taken as a dynamic input and different questions can be answered using the same agentic application. Example, our current application can also answer questions like “What are the dietary preferences of the user”, “How much budget is available with the user”, “Create a grocery list for weight gainer diet under 2000 rupees”, etc.Tool Integration
The function get_tools() retrieves the necessary tools—fetching user preferences, generating a grocery list, and creating the final meal plan. These tools allow the agent to interact with external data sources and action executors dynamically. The capability of the agentic application is driven by the tools available.Prompt Structuring
The get_prompt() function retrieves the structured ReAct-style prompt, which serves as the agent’s guiding framework, helping it decide the next steps logically rather than following a rigid script. As promised let’s finally understand the ReAct prompt,
A ReAct prompt is simply a step-by-step guide given to the LLM so that it can think and act smartly. Its goal is to solve problems by thinking, using tools, and learning from results.
The LLM is prompted to go through a series of steps of Thought, Action, Action Input, Observation, Repeat, and Final Answer.
Given the inputs, Question and Tools described above the LLM is asked to follow the steps,
3.1 Thought: LLM thinks about the input question carefully. It considers what information it needs to find the answer.
3.2 Action: The LLM chooses the most appropriate tool to get the information it needs as per the current thought process
3.3 Action Input: The LLM identifies the inputs that are required to successfully call the identified tool in the previous “Action” step.
3.4 Observation: After the identified tool is executed the LLM observes the result returned but the tool. It learns from this information to decide what to do next.
3.5 Repeat if Needed: Based on the observations made the LLM identifies if all the information required to answer the user question is available. If not the LLM goes back to the “Thought” step and follows the same process N times till the final answer is available.
3.6 Final Answer: Once the LLM observes that the answer to the user question is available it creates a well-structured final answer and ends the flow.
Let’s look at a sample execution of a ReAct Flow to make the understanding more concrete,
Question: What are the dietary preferences for the user id 1
Thought: I need to fetch the user's dietary preferences, I should use the get_user_preferences tool
Action: get_user_preferences
Action Input: 1
Observation: "diet: keto, health goal: weight loss, preferred ingredients: avocado, chicken, spinach, budget: 1500 rupees"
Thought: I now know the final answer.
Final Answer: The user follows a keto diet with a health goal of weight loss, prefers ingredients like avocado, chicken, and spinach, and has a budget of 1500 rupees.
Agent Creation
Using create_react_agent(), we initialize an agent powered by an LLM, embedding reasoning and decision-making capabilities into the process.Agent Execution
The AgentExecutor runs the agent, ensuring it follows a structured process, selecting the right tools, and dynamically handling intermediate steps.Dynamic Execution & Response Generation
Finally, the agent invokes tools step by step, making decisions based on retrieved data, and iteratively refines its approach. Finally, it generates a well-structured, personalized meal plan based on the user’s dietary goals, budget, and preferences.
This approach exemplifies the power of AI agents—leveraging structured reasoning, dynamic decision-making, and external tool usage to generate highly personalized and contextually accurate results. Unlike static LLM responses, our meal planner agent adapts to the user’s needs in real-time, ensuring optimal meal plans that align with dietary and financial constraints.
With this, we’ve successfully built an AI-driven agent that not only understands user requirements but also actively retrieves data, plans intelligently, and delivers meaningful insights. This marks the transition from traditional LLMs to fully functional, task-oriented AI agents—offering a glimpse into the future of AI-driven automation
Disadvantages of AI Agents
Cost
Running AI agents, especially those utilizing large language models, requires substantial computational resources, such as powerful GPUs or cloud-based services. This can lead to high operational costs.
Fine-tuning LLMs for specific tasks can be expensive, as it demands significant amounts of data and computational power, further increasing the investment needed.
Maintaining AI agents involves continuous updates, monitoring, and troubleshooting, all of which add to the overall expenses over time.
Time
AI agents may exhibit slow inference speeds, especially when dealing with complex queries that require multi-step reasoning and planning. This can result in longer response times compared to more straightforward, rule-based systems.
Getting Stuck in a Loop
One challenge with LLM agents is the potential to get stuck in loops, generating repetitive or circular responses, particularly when faced with unclear or poorly structured inputs.
Redirecting the output can be difficult without manual intervention, making it challenging to build fully automated systems that are reliable and capable of handling a wide range of scenarios autonomously.
How About Some Homework?
The AI meal planner is great, but why stop there? Here are some ways to take it to the next level:
Detailed Recipes – Automatically generate step-by-step cooking instructions from the meal plan.
Nutritional Insights – Provide calorie counts and dietary recommendations for each meal.
Application Setup
Install the required Python modules using the below poetry commands,
poetry add langchain
poetry add langchain-openai
poetry add python-dotenvCreate a .env file and add the Open AI API Key,
OPENAI_API_KEY=******************************If you are using any other model add the required configurations for the same in .env.
Complete Code
import json
from dotenv import load_dotenv
from langchain.agents import create_react_agent, AgentExecutor
from langchain_core.messages import SystemMessage
from langchain_core.prompts import PromptTemplate
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
load_dotenv()
llm = ChatOpenAI(temperature=0, model_name="gpt-4o-mini")
@tool
def get_user_preferences(user_id: int) -> str:
"""Fetches the user's dietary preferences and health goals."""
return "diet: keto, health goal: weight loss, preferred ingredients: avocado, chicken, spinach, budget: 1500 rupees "
@tool
def get_grocery_list(inputs: str) -> str:
"""Suggests a grocery list based on diet and budget.
inputs: {"diet": "user's diet type", "budget": "budget with currency", "preferred_ingredients": "list of preferred ingredients"}"""
input = json.loads(inputs)
system_message = SystemMessage(
content=f"""Create a personalized grocery list for a {input['diet']} diet.
The user preferences includes: {input['preferred_ingredients']}.
Consider other similar items that the user would like.
Keep the budget under: {input['budget']}.
Consider items and quantity for a week. Do not add any meal details.""")
return llm.invoke([system_message]).content
@tool
def get_meal_plan(inputs: str) -> str:
"""Creates a structured meal plan based on:
All input parameters are mandatory:
inputs: {"diet": "user's diet type", "health_goal": "user's health goals",
"grocery_list": "suggested grocery list"}"""
input = json.loads(inputs)
system_message = SystemMessage(content=f"""Create a personalized meal plan for a {input['diet']} diet with a goal of {input['health_goal']}.
The grocery list includes: {input['grocery_list']}.
Keep the meal plan structured and simple.""")
return llm.invoke([system_message]).content
def get_tools():
tools = [get_user_preferences, get_grocery_list, get_meal_plan]
return tools
def get_prompt():
return PromptTemplate(template="""Answer the following questions as best you can. You have access to the following tools:
{tools}
Use the following format:
Question: the input question you must answer
Thought: you should always think about what to do. Never assume action inputs, either fetch from other tools or ask user.
Action: the action to take, should be one of [{tool_names}]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question
Begin!
Question: {input}
Thought:{agent_scratchpad}""")
def start():
user_question = "Create a personalized meal plan for user id 1"
tools = get_tools()
react_prompt = get_prompt()
agent = create_react_agent(llm=llm, tools=tools, prompt=react_prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True,
handle_parsing_errors=True)
result = agent_executor.invoke(input={"input": user_question})
print(result)
start()
Output
I need to first fetch the user's dietary preferences and health goals to create a personalized meal plan.
Action: get_user_preferences
Action Input: 1diet: keto, health goal: weight loss, preferred ingredients: avocado, chicken, spinach, budget: 1500 rupees
I now have the user's dietary preferences, health goals, and budget. Next, I need to create a grocery list based on these inputs.
Action: get_grocery_list
Action Input: {"diet": "keto", "budget": "1500 rupees", "preferred_ingredients": "avocado, chicken, spinach"}
Here's a personalized grocery list for a keto diet based on your preferences, including avocado, chicken, and spinach. The list is designed to keep your budget under 1500 rupees for a week.
### Grocery List
#### Proteins
1. **Chicken Breast** - 1 kg (approx. 300-400 rupees)
2. **Eggs** - 1 dozen (approx. 100-150 rupees)
3. **Paneer** - 500 grams (approx. 200-250 rupees)
#### Vegetables
4. **Spinach** - 500 grams (approx. 50-70 rupees)
5. **Avocado** - 3 medium-sized (approx. 150-200 rupees)
6. **Broccoli** - 500 grams (approx. 50-70 rupees)
7. **Zucchini** - 500 grams (approx. 50-70 rupees)
8. **Cauliflower** - 1 medium head (approx. 50-70 rupees)
#### Healthy Fats
9. **Olive Oil** - 250 ml (approx. 200-300 rupees)
10. **Coconut Oil** - 250 ml (approx. 150-200 rupees)
11. **Nuts (Almonds or Walnuts)** - 200 grams (approx. 150-200 rupees)
#### Dairy
12. **Greek Yogurt (unsweetened)** - 500 grams (approx. 150-200 rupees)
#### Seasonings and Condiments
13. **Salt** - 1 pack (approx. 20-30 rupees)
14. **Black Pepper** - 1 pack (approx. 20-30 rupees)
15. **Garlic Powder** - 1 pack (approx. 20-30 rupees)
16. **Chili Powder** - 1 pack (approx. 20-30 rupees)
### Estimated Total Cost
- Proteins: 600-800 rupees
- Vegetables: 400-500 rupees
- Healthy Fats: 400-600 rupees
- Dairy: 150-200 rupees
- Seasonings: 100-150 rupees
### Grand Total: Approximately 1300-1500 rupees
This list includes a variety of keto-friendly foods that align with your preferences and should last you for a week. Adjust quantities based on your specific needs and local prices. Happy shopping!
Now that I have the grocery list, I can create a structured meal plan based on the user's diet, health goals, and the suggested grocery list.
Action: get_meal_plan
Action Input: {"diet": "keto", "health_goal": "weight loss", "grocery_list": "Here's a personalized grocery list for a keto diet based on your preferences, including avocado, chicken, and spinach. The list is designed to keep your budget under 1500 rupees for a week.\n\n### Grocery List\n\n#### Proteins\n1. **Chicken Breast** - 1 kg (approx. 300-400 rupees)\n2. **Eggs** - 1 dozen (approx. 100-150 rupees)\n3. **Paneer** - 500 grams (approx. 200-250 rupees)\n\n#### Vegetables\n4. **Spinach** - 500 grams (approx. 50-70 rupees)\n5. **Avocado** - 3 medium-sized (approx. 150-200 rupees)\n6. **Broccoli** - 500 grams (approx. 50-70 rupees)\n7. **Zucchini** - 500 grams (approx. 50-70 rupees)\n8. **Cauliflower** - 1 medium head (approx. 50-70 rupees)\n\n#### Healthy Fats\n9. **Olive Oil** - 250 ml (approx. 200-300 rupees)\n10. **Coconut Oil** - 250 ml (approx. 150-200 rupees)\n11. **Nuts (Almonds or Walnuts)** - 200 grams (approx. 150-200 rupees)\n\n#### Dairy\n12. **Greek Yogurt (unsweetened)** - 500 grams (approx. 150-200 rupees)\n\n#### Seasonings and Condiments\n13. **Salt** - 1 pack (approx. 20-30 rupees)\n14. **Black Pepper** - 1 pack (approx. 20-30 rupees)\n15. **Garlic Powder** - 1 pack (approx. 20-30 rupees)\n16. **Chili Powder** - 1 pack (approx. 20-30 rupees)\n\n### Estimated Total Cost\n- Proteins: 600-800 rupees\n- Vegetables: 400-500 rupees\n- Healthy Fats: 400-600 rupees\n- Dairy: 150-200 rupees\n- Seasonings: 100-150 rupees\n\n### Grand Total: Approximately 1300-1500 rupees\n\nThis list includes a variety of keto-friendly foods that align with your preferences and should last you for a week. Adjust quantities based on your specific needs and local prices. Happy shopping!"}
I now know the final answer.
Final Answer: Here is a personalized 7-day keto meal plan for user id 1, designed to help with weight loss based on their dietary preferences and grocery list:
### 7-Day Keto Meal Plan
#### Day 1
- **Breakfast:** Scrambled eggs with spinach cooked in olive oil
- **Lunch:** Grilled chicken breast with a side of sautéed zucchini
- **Dinner:** Paneer stir-fry with broccoli and garlic powder
- **Snack:** Half an avocado
#### Day 2
- **Breakfast:** Greek yogurt topped with a handful of almonds
- **Lunch:** Chicken salad with spinach, avocado, and olive oil dressing
- **Dinner:** Baked chicken breast with roasted cauliflower
- **Snack:** A few walnuts
#### Day 3
- **Breakfast:** Omelette with spinach and cheese (if available)
- **Lunch:** Paneer and broccoli stir-fry with chili powder
- **Dinner:** Grilled chicken with zucchini noodles
- **Snack:** Half an avocado
#### Day 4
- **Breakfast:** Greek yogurt with a sprinkle of garlic powder and black pepper
- **Lunch:** Chicken breast with sautéed spinach in coconut oil
- **Dinner:** Cauliflower rice with paneer and spices
- **Snack:** A handful of almonds
#### Day 5
- **Breakfast:** Scrambled eggs with diced avocado
- **Lunch:** Grilled chicken salad with mixed greens (if available) and olive oil
- **Dinner:** Broccoli and paneer curry with coconut oil
- **Snack:** A few walnuts
#### Day 6
- **Breakfast:** Greek yogurt with a few chopped nuts
- **Lunch:** Chicken breast with roasted zucchini and garlic
- **Dinner:** Stir-fried spinach with paneer and chili powder
- **Snack:** Half an avocado
#### Day 7
- **Breakfast:** Omelette with spinach and a side of Greek yogurt
- **Lunch:** Chicken salad with avocado and olive oil dressing
- **Dinner:** Baked cauliflower with paneer and spices
- **Snack:** A handful of almonds
### Tips for Meal Preparation
- **Batch Cooking:** Prepare larger portions of chicken, paneer, and vegetables at the beginning of the week to save time.
- **Seasoning:** Use your seasonings to add flavor to your meals without adding carbs.
- **Hydration:** Drink plenty of water throughout the day, and consider herbal teas or black coffee as well.
### Adjustments
Feel free to adjust portion sizes based on your hunger levels and activity. If you find yourself needing more calories, you can increase the amount of healthy fats (like olive oil or coconut oil) in your meals.
This meal plan is designed to be simple and easy to follow while keeping you within your grocery budget. Enjoy your keto journey!
Resources:
https://www.youtube.com/watch?v=sal78ACtGTc&t=134s&ab_channel=SequoiaCapital
https://medium.com/@turungkadircan/agentic-design-patterns-how-to-implement-19c881b54dd7
https://github.com/menloparklab/LangGraphJourney/blob/main/LangGraphLearning.ipynb
https://developer.nvidia.com/blog/introduction-to-llm-agents/
