In this tutorial, we begin by setting up a compact yet capable AI agent that runs smoothly, leveraging Hugging Face transformers. We integrate dialog generation, question‑answering, sentiment analysis, web search stubs, weather look‑ups, and a safe calculator into a single Python class. As we progress, we install only the essential libraries, load lightweight models that respect Colab’s memory limits, and wrap each capability inside tidy, reusable methods. Together, we explore how every component, from intent detection to device-aware model loading, fits into a coherent workflow, empowering us to prototype sophisticated, multi-tool agents.
!pip install transformers torch accelerate datasets requests beautifulsoup4
import torch
import json
import requests
from datetime import datetime
from transformers import (
AutoTokenizer, AutoModelForCausalLM, AutoModelForSequenceClassification,
AutoModelForQuestionAnswering, pipeline
)
from bs4 import BeautifulSoup
import warnings
warnings.filterwarnings('ignore')We begin by installing the key Python libraries, Transformers, Torch, Accelerate, Datasets, Requests, and BeautifulSoup, so our Colab environment has everything it needs for model loading, inference, and web scraping. Next, we import PyTorch, JSON utilities, HTTP and date helpers, Hugging Face classes for generation, classification, and QA, as well as BeautifulSoup for HTML parsing, while silencing unnecessary warnings to keep the notebook output clean.
class AdvancedAIAgent:
def __init__(self):
"""Initialize the AI Agent with multiple models and capabilities"""
self.device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"🚀 Initializing AI Agent on {self.device}")
self._load_models()
self.tools = {
"web_search": self.web_search,
"calculator": self.calculator,
"weather": self.get_weather,
"sentiment": self.analyze_sentiment
}
print("✅ AI Agent initialized successfully!")
def _load_models(self):
"""Load all required models"""
print("📥 Loading models...")
self.gen_tokenizer = AutoTokenizer.from_pretrained("microsoft/DialoGPT-medium")
self.gen_model = AutoModelForCausalLM.from_pretrained("microsoft/DialoGPT-medium")
self.gen_tokenizer.pad_token = self.gen_tokenizer.eos_token
self.sentiment_pipeline = pipeline(
"sentiment-analysis",
model="cardiffnlp/twitter-roberta-base-sentiment-latest",
device=0 if self.device == "cuda" else -1
)
self.qa_pipeline = pipeline(
"question-answering",
model="distilbert-base-cased-distilled-squad",
device=0 if self.device == "cuda" else -1
)
print("✅ All models loaded!")
def generate_response(self, prompt, max_length=100, temperature=0.7):
"""Generate text response using the language model"""
inputs = self.gen_tokenizer.encode(prompt + self.gen_tokenizer.eos_token,
return_tensors="pt")
with torch.no_grad():
outputs = self.gen_model.generate(
inputs,
max_length=max_length,
temperature=temperature,
do_sample=True,
pad_token_id=self.gen_tokenizer.eos_token_id,
attention_mask=torch.ones_like(inputs)
)
response = self.gen_tokenizer.decode(outputs[0][len(inputs[0]):],
skip_special_tokens=True)
return response.strip()
def analyze_sentiment(self, text):
"""Analyze sentiment of given text"""
result = self.sentiment_pipeline(text)[0]
return {
"sentiment": result['label'],
"confidence": round(result['score'], 4),
"text": text
}
def answer_question(self, question, context):
"""Answer questions based on given context"""
result = self.qa_pipeline(question=question, context=context)
return {
"answer": result['answer'],
"confidence": round(result['score'], 4),
"question": question
}
def web_search(self, query):
"""Simulate web search (replace with actual API if needed)"""
try:
return {
"query": query,
"results": f"Search results for '{query}': Latest information retrieved successfully.",
"timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
}
except Exception as e:
return {"error": f"Search failed: {str(e)}"}
def calculator(self, expression):
"""Safe calculator function"""
try:
allowed_chars = set('0123456789+-*/.() ')
if not all(c in allowed_chars for c in expression):
return {"error": "Invalid characters in expression"}
result = eval(expression)
return {
"expression": expression,
"result": result,
"type": type(result).__name__
}
except Exception as e:
return {"error": f"Calculation failed: {str(e)}"}
def get_weather(self, location):
"""Mock weather function (replace with actual weather API)"""
return {
"location": location,
"temperature": "22°C",
"condition": "Partly cloudy",
"humidity": "65%",
"note": "This is mock data. Integrate with a real weather API for actual data."
}
def detect_intent(self, user_input):
"""Simple intent detection based on keywords"""
user_input = user_input.lower()
if any(word in user_input for word in ['calculate', 'math', '+', '-', '*', '/']):
return 'calculator'
elif any(word in user_input for word in ['weather', 'temperature', 'forecast']):
return 'weather'
elif any(word in user_input for word in ['search', 'find', 'look up']):
return 'web_search'
elif any(word in user_input for word in ['sentiment', 'emotion', 'feeling']):
return 'sentiment'
elif '?' in user_input:
return 'question_answering'
else:
return 'chat'
def process_request(self, user_input, context=""):
"""Main method to process user requests"""
print(f"🤖 Processing: {user_input}")
intent = self.detect_intent(user_input)
response = {"intent": intent, "input": user_input}
try:
if intent == 'calculator':
import re
expr = re.findall(r'[0-9+\-*/.() ]+', user_input)
if expr:
result = self.calculator(expr[0].strip())
response.update(result)
else:
response["error"] = "No valid mathematical expression found"
elif intent == 'weather':
words = user_input.split()
location = "your location"
for i, word in enumerate(words):
if word.lower() in ['in', 'at', 'for']:
if i + 1 < len(words):
location = words[i + 1]
break
result = self.get_weather(location)
response.update(result)
elif intent == 'web_search':
query = user_input.replace('search', '').replace('find', '').strip()
result = self.web_search(query)
response.update(result)
elif intent == 'sentiment':
text_to_analyze = user_input.replace('sentiment', '').strip()
if not text_to_analyze:
text_to_analyze = "I'm feeling great today!"
result = self.analyze_sentiment(text_to_analyze)
response.update(result)
elif intent == 'question_answering' and context:
result = self.answer_question(user_input, context)
response.update(result)
else:
generated_response = self.generate_response(user_input)
response["response"] = generated_response
response["type"] = "generated_text"
except Exception as e:
response["error"] = f"Error processing request: {str(e)}"
return responseWe encapsulate our entire toolkit inside an AdvancedAIAgent class that boots on GPU when available, loads dialogue, sentiment, and QA models, and registers helper tools for search, weather, and arithmetic. With lightweight keyword-based intent detection, we dynamically route each user message to the right pipeline or fall back to free-form generation, providing a unified, multi-skill agent driven by just a few clean methods.
if __name__ == "__main__":
agent = AdvancedAIAgent()
print("\n" + "="*50)
print("🎯 DEMO: Advanced AI Agent Capabilities")
print("="*50)
test_cases = [
"Calculate 25 * 4 + 10",
"What's the weather in Tokyo?",
"Search for latest AI developments",
"Analyze sentiment of: I love working with AI!",
"Hello, how are you today?"
]
for test in test_cases:
print(f"\n👤 User: {test}")
result = agent.process_request(test)
print(f"🤖 Agent: {json.dumps(result, indent=2)}")
"""
print("\n🎮 Interactive Mode - Type 'quit' to exit")
while True:
user_input = input("\n👤 You: ")
if user_input.lower() == 'quit':
break
result = agent.process_request(user_input)
print(f"🤖 Agent: {json.dumps(result, indent=2)}")
"""
We conclude by spawning the AdvancedAIAgent, announcing a quick demo section, and firing five representative prompts that test calculation, weather, search, sentiment, and open‑ended chat in one sweep. After reviewing the neatly formatted JSON replies, we keep an optional interactive loop on standby, ready for live experimentation whenever we decide to un‑comment it.
In conclusion, we test a variety of real-world prompts and observe how it handles arithmetic, fetches mock weather data, gauges sentiment, and engages in natural conversation, all through a single unified interface using Hugging Face models. This exercise demonstrates how we can stitch multiple NLP tasks into an extensible framework that remains friendly to Colab resources.
Check out the Codes. All credit for this research goes to the researchers of this project.
Asif Razzaq is the CEO of Marktechpost Media Inc.. As a visionary entrepreneur and engineer, Asif is committed to harnessing the potential of Artificial Intelligence for social good. His most recent endeavor is the launch of an Artificial Intelligence Media Platform, Marktechpost, which stands out for its in-depth coverage of machine learning and deep learning news that is both technically sound and easily understandable by a wide audience. The platform boasts of over 2 million monthly views, illustrating its popularity among audiences.
