Introduction
In today's rapidly evolving AI landscape, enterprises are increasingly seeking to build their own customized AI agents rather than relying on third-party solutions or frontier AI labs. Prime Intellect's Series A funding reflects this growing demand for self-contained AI systems. This tutorial will guide you through creating a basic agentic system using Python, demonstrating core concepts that align with what Prime Intellect aims to enable for enterprises.
By the end of this tutorial, you'll understand how to design a simple yet functional AI agent that can interact with external APIs, process information, and make decisions based on user input.
Prerequisites
- Basic understanding of Python programming
- Python 3.8 or higher installed
- Access to an API key for a weather service (we'll use OpenWeatherMap)
- Knowledge of REST APIs and HTTP requests
- Basic understanding of object-oriented programming concepts
Step-by-Step Instructions
1. Set up your development environment
First, create a new Python project directory and install the required dependencies. The core libraries we'll use are requests for API calls and openai for LLM integration.
mkdir ai-agent-project
cd ai-agent-project
python -m venv venv
source venv/bin/activate # On Windows: venv\Scripts\activate
pip install requests openaiWhy this step? Setting up a virtual environment isolates your project dependencies and prevents conflicts with other Python projects on your system.
2. Get your API key
Sign up at OpenWeatherMap to get a free API key. This will allow your agent to fetch real-time weather data.
Why this step? Real-world AI agents need to interact with external data sources to provide meaningful responses to users.
3. Create the base agent class
Start by creating a basic agent structure that can handle communication with external services.
import requests
import json
class WeatherAgent:
def __init__(self, api_key):
self.api_key = api_key
self.base_url = "http://api.openweathermap.org/data/2.5/weather"
def get_weather(self, city):
params = {
'q': city,
'appid': self.api_key,
'units': 'metric'
}
response = requests.get(self.base_url, params=params)
if response.status_code == 200:
return response.json()
else:
return NoneWhy this step? This establishes the foundation of your agent, defining how it will interact with the weather API.
4. Add decision-making capabilities
Enhance your agent by adding basic reasoning capabilities. We'll implement a simple decision tree for weather-based recommendations.
def analyze_weather(self, weather_data):
if not weather_data:
return "Unable to fetch weather data."
temp = weather_data['main']['temp']
description = weather_data['weather'][0]['description']
if temp < 0:
recommendation = "It's freezing! Bundle up and stay warm."
elif temp < 10:
recommendation = "It's quite cold. Wear a warm jacket."
elif temp < 20:
recommendation = "It's mild. Perfect weather for a walk."
else:
recommendation = "It's warm. Stay hydrated and wear light clothing."
return f"Temperature: {temp}°C, Conditions: {description}. {recommendation}"
def process_request(self, user_input):
# Simple parsing to extract city name
words = user_input.lower().split()
city = None
for i, word in enumerate(words):
if word in ['in', 'at', 'for'] and i + 1 < len(words):
city = words[i + 1]
break
if not city:
return "I couldn't identify a city in your request."
weather_data = self.get_weather(city)
return self.analyze_weather(weather_data)Why this step? This demonstrates how an agent can process user input, fetch relevant data, and make decisions based on that information.
5. Implement the main interaction loop
Create a simple command-line interface that allows users to interact with your agent.
def main():
# Replace with your actual API key
API_KEY = "your_openweathermap_api_key_here"
agent = WeatherAgent(API_KEY)
print("Weather Agent is ready! Ask me about weather in any city.")
print("Type 'quit' to exit.")
while True:
user_input = input("\nYou: ")
if user_input.lower() in ['quit', 'exit', 'bye']:
print("Agent: Goodbye!")
break
response = agent.process_request(user_input)
print(f"Agent: {response}")
if __name__ == "__main__":
main()Why this step? This creates a user-friendly interface that demonstrates how your agent would function in a real-world scenario.
6. Test your agent
Run your agent and test it with various inputs to ensure it functions correctly.
python weather_agent.pyTry inputs like:
- "What's the weather in London?"
- "Tell me about the weather in Tokyo"
- "Weather in Paris"
Why this step? Testing validates that your agent works as expected and helps identify any edge cases or issues in the implementation.
7. Extend functionality (optional)
For a more advanced implementation, consider adding:
- Natural Language Processing (NLP) for better input parsing
- Memory capabilities to remember previous interactions
- Multiple API integrations for richer data
- Logging and error handling improvements
# Example of enhanced input parsing
import re
class EnhancedWeatherAgent(WeatherAgent):
def extract_city(self, user_input):
# Use regex for more robust city name extraction
city_pattern = r"(?:in|at|for|from)\s+([\w\s]+)"
match = re.search(city_pattern, user_input, re.IGNORECASE)
if match:
return match.group(1).strip()
# Fallback to first word after "weather"
weather_pattern = r"weather\s+(\w+)"
match = re.search(weather_pattern, user_input, re.IGNORECASE)
if match:
return match.group(1)
return NoneWhy this step? Extending functionality shows how enterprises might build upon basic agent capabilities to create more sophisticated systems.
Summary
This tutorial demonstrated how to build a foundational AI agent capable of fetching weather data and providing contextual recommendations. While this example is simple, it illustrates key concepts that Prime Intellect aims to enable for enterprises: building custom AI systems that can interact with external data sources and make intelligent decisions.
The agent we created can be extended with more complex reasoning, additional APIs, and improved natural language understanding. This approach aligns with the trend toward enterprises developing their own AI capabilities rather than relying on external providers, offering greater control, customization, and security.
As you continue developing your agent, consider how you might integrate it with other enterprise systems, add machine learning capabilities, or implement more sophisticated decision-making algorithms to match the capabilities that Prime Intellect is enabling for organizations.
