LLM Agents Under the Hood: I Built One with Google's Python SDK

 I built advanced LLM (Large Language Model) Agents from the ground up using Python and the Google Generative AI package. I won't just show you the code; I'll explain exactly how agents work under the hood, from reasoning and planning to tool execution. 

  This tutorial is perfect for a developer, data scientist, or AI enthusiast ready to move from simple prompt engineering to building truly Agentic AI applications.

 

 

 

PREREQUISITES:

• Basic knowledge of Python. 
• A Google AI Studio API Key (it's free!).

•  pip install google-generativeai python-dotenv

 Create new file named "shopping_agent.py" and add below code inside the file. 

 def confirm_shopping_order(product, quantity,address) -> str:  
      """  
      Function-callable API for Confirm a shopping order.  
      params: dict with keys 'product', 'quantity', 'address', etc.  
      """  
      #API call to search product availability can be added here  
      prompt = (  
           "You are a shopping assistant. "  
           "Following is the List of products available : "       
           "| Product Id | Brand | Product Name | Price |"  
           "|------------|-------|--------------|-------|"  
 "| 012121 | Bata | Formal Leather Shoes | ₹2,499 |"  
 "| 012122 | Metro | Casual Loafers | ₹1,799 |"  
 "| 012123 | Paragon | Sports Sandals | ₹899 |"  
 "| 012124 | Liberty | Executive Formal Shoes | ₹3,499 |"  
 "| 012125 | Action | Running Shoes | ₹1,299 |"  
 "| 012126 | Woodland | Outdoor Trekking Shoes | ₹4,999 |"  
 "| 012127 | Relaxo | Everyday Flip Flops | ₹399 |"  
 "| 012128 | Red Tape | Casual Sneakers | ₹2,199 |"  
 "| 012129 | Campus | Sports Shoes | ₹1,599 |"  
 "| 012130 | Lancer | School Shoes | ₹799 |\r\n"        
           f"Quantity asked: {quantity}, "  
           f"Address to deliver: {address}. "  
           f"product to deliver: {product}. "  
           "If any information is missing, ask for it. Take product confirmation by user."  
      )  
      print(prompt)  
      return prompt  
 def place_shopping_order(productId,brand, product, quantity,address, price) -> str:  
      """  
      Function-callable API for placing a shopping order.  
      params: dict with keys 'productId','product','Brand', 'quantity', 'address', etc.  
      """  
      #API call to place order can be added here  
      prompt = (  
           "You are a shopping assistant. "  
           "Follwing Order is Placed: "  
           f"Product Id: {productId}, "  
           f"Brand: {brand}, "  
           f"Product: {product}, "  
           f"Quantity: {quantity}, "  
           f"Address: {address}. "  
           f"Price: {price} "  
           "If any more order to place, ask for it."  
      )  
      print(prompt)  
      return prompt  
 # Example function schema for tool registration  
 CONFIRM_SHOPPING_ORDER_SCHEMA = {   
      "name": "confirm_shopping_order",  
      "description": "confirm a shopping order before placing order for a user.",  
      "parameters": {  
           "type": "object",  
           "properties": {  
                "product": {"type": "string", "description": "Product to order"},  
                "quantity": {"type": "string", "description": "Quantity of the product"},  
                "address": {"type": "string", "description": "Delivery address"}  
           },  
           "required": ["product", "quantity", "address"]  
      }  
 }  
 # Example function schema for tool registration  
 PLACE_SHOPPING_ORDER_SCHEMA = {  
      "name": "place_shopping_order",  
      "description": "Place a shopping order for a user.",  
      "parameters": {  
           "type": "object",  
           "properties": {  
                "productId": {"type": "string", "description": "Product id to order"},  
                "brand": {"type": "string", "description": "Brand of the Product to order"},  
                "product": {"type": "string", "description": "Product to order"},  
                "quantity": {"type": "string", "description": "Quantity of the product"},  
                "price": {"type": "string", "description": "Price of the product"},  
                "address": {"type": "string", "description": "Delivery address"}  
           },  
           "required": ["product", "quantity", "address"]  
      }  
 }  

 Create new file named "train_ticket_agent.py" and add below code inside the file.  

 def book_train_ticket(from_location, to_location, date,passenger_name) -> str:  
      """  
      Function-callable API for booking train tickets.  
      params: 'from_location', 'to_location', 'date', 'passenger_name', etc.  
      """  
      prompt = (  
           "You are a train ticket booking assistant. "  
           "Book a train ticket with the following details: "  
           f"From: {from_location}, "  
           f"To: {to_location}, "  
           f"Date: {date}, "  
           f"Passenger: {passenger_name}. "  
           "If any information is missing, ask for it."  
      )  
      print(prompt)  
      return prompt  
 # Example function schema for tool registration  
 BOOK_TRAIN_TICKET_SCHEMA = {  
      "name": "book_train_ticket",  
      "description": "Book a train ticket for a user.",  
      "parameters": {  
           "type": "object",  
           "properties": {  
                "from_location": {"type": "string", "description": "Departure city or station"},  
                "to_location": {"type": "string", "description": "Arrival city or station"},  
                "date": {"type": "string", "description": "Date of travel"},  
                "passenger_name": {"type": "string", "description": "Name of the passenger"}  
           },  
           "required": ["from_location", "to_location", "date", "passenger_name"]  
      }  
 }  

 Create new file named "main.py" and add below code inside the file. 

 import sys  
 from pathlib import Path  
 # Ensure project root is on sys.path so "agents" package can be imported  
 _project_root = Path(__file__).resolve().parents[1]  
 if str(_project_root) not in sys.path:  
   sys.path.insert(0, str(_project_root))  
 import os  
 from dotenv import load_dotenv  
 import google.generativeai as genai  
 from agents.train_ticket_agent import book_train_ticket, BOOK_TRAIN_TICKET_SCHEMA   
 from agents.shopping_agent import confirm_shopping_order,place_shopping_order, PLACE_SHOPPING_ORDER_SCHEMA,CONFIRM_SHOPPING_ORDER_SCHEMA  
 from google.generativeai import types  
 def main():  
      load_dotenv()  
      api_key = os.getenv("GEMINI_API_KEY")  
      if not api_key:  
           print("Please set the GEMINI_API_KEY environment variable in your .env file.")  
           return  
      genai.configure(api_key=os.getenv("GEMINI_API_KEY"))  
      # Register agent functions as tools  
      tools = [genai.types.Tool(function_declarations=[  
           BOOK_TRAIN_TICKET_SCHEMA,  
           CONFIRM_SHOPPING_ORDER_SCHEMA,            
           PLACE_SHOPPING_ORDER_SCHEMA  
      ])]  
      systemPrompt = (     "You are an intelligent assistant that can help users with various tasks such as booking train tickets, "  
           "Confirming the shopping order first with user then place the shopping orders. Call appropriate tool as per provided tools metadata in proper order to smooth agent workflow. ")  
      model = genai.GenerativeModel(model_name='models/gemini-2.5-flash',tools=tools,system_instruction=systemPrompt)  
      print("Agentic App: LlamaIndex + Google Gemini (Function Calling)")  
      print("Type 'exit' to quit.")  
      contents=[]  
      while True:  
           user_input = input("\nEnter your request: ")  
           if user_input.lower() == 'exit':  
                break        
           if contents.__len__() > 10:  
                contents=contents[10:]                 
           if contents.__len__()==0:       
                contents = [ types.ContentDict(role="user", parts=[types.PartDict(text=user_input)])]        
           else:  
                contents.append(types.ContentDict(role="user", parts=[types.PartDict(text=user_input)]))       
           print(Call_model(contents,model))  
 def Call_model(user_input, model) -> str:  
           innerResult= ""  
           result = model.generate_content(user_input)   
           user_input.append(result.candidates[0].content)             
           if(result.parts.__str__().__contains__("function_call")):                 
                for fn in result.parts:  
                     function_call =fn.function_call                  
                     function_name = function_call.name  
                     function_args = function_call.args  
                     for tool in model._tools._tools:                            
                          for fnc in tool._function_declarations:                                
                               if fnc.name == function_name:  
                                    print(f"Calling function: {function_name} with args: {function_args}")  
                                    funResult = ""  
                                         # Call the appropriate function based on the function name  
                                    if function_name == "book_train_ticket":  
                                         funResult = book_train_ticket(**function_args)  
                                    elif function_name == "confirm_shopping_order":  
                                         funResult = confirm_shopping_order(**function_args)  
                                    elif function_name == "place_shopping_order":  
                                         funResult = place_shopping_order(**function_args)  
                                    else:  
                                         funResult = f"Unknown function: {function_name}"                                
                                    user_input.append(types.ContentDict(role="Model", parts=["tool `{function_name}` response : "+funResult]))  
                innerResult= Call_model(user_input,model)                 
           return innerResult if innerResult.__len__() > 0 else getOutputString(result,user_input)   
 def getOutputString(result,user_input) -> str:  
      finalOtupt=[]  
      if(result.candidates.__len__()>0):       
           for part in result.candidates[0].content.parts:  
                finalOtupt.append(part.text)  
           user_input.append(types.ContentDict(role="Model", parts=[types.PartDict(text=" ".join(finalOtupt))]))  
      return " ".join(finalOtupt)  
 if __name__ == "__main__":  
      main()  

  Create new file named ".env" and add below keys inside the file. 

 # .env file for Gemini API Key  
 GEMINI_API_KEY=Add your gemini key  

 Now Run the application by firing below command in terminal.

 python main.py  

 Below is the output of above application after executing the application.