Building intelligent solutions with Python, Django, React, and cutting-edge AI technologies
Welcome to my comprehensive Python portfolio showcasing progressive mastery from fundamental programming concepts to production-ready full-stack applications and AI-powered enterprise solutions.
This repository demonstrates my journey through 14 structured learning modules and 11 production-scale projects, encompassing:
- 🎯 50+ Python programs ranging from basic algorithms to complex systems
- 🤖 AI-Powered HR Management System with Llama 3 integration
- ⚡ Full-Stack Django-React Application with JWT authentication
- 🤖 AI-Powered Meeting System with real-time transcription and analysis
- 🌤️ MCP Weather Servers in TypeScript and Python with Claude Desktop integration
- 🤖 AI Data Generator Agent with LangChain and Google Gemini for sample data generation
- 🧠 21-RAG-AI Advanced RAG System with Google Gemini, Inngest, and Streamlit
- 🔍 22-AI-Search-Agent Multi-Source Research Agent with Bright Data, Google Gemini, and Reddit integration
- 🔧 23-AI-Agent Multi-LLM Evaluation System with OpenAI, Google Gemini, Ollama, and real-time evaluation
- 🤝 24-AI-Career-Assistant Professional AI Assistant with tool use, Pushover notifications, and contextual responses
- 🎭 27-CrewAI-Debate Multi-Agent Debate System with CrewAI, structured argumentation, and real-time debate orchestration
- 💰 28-CrewAI-Financial-Researcher Real-Time Financial Analysis System with CrewAI, SerperDevTool, and live market data integration
- 📈 29-CrewAI-Stock-Picker Intelligent Investment Analysis System with CrewAI, hierarchical management, persistent memory, and real-time notifications
- 💻 30-CrewAI-Coder AI-Powered Code Generation System with CrewAI, Docker Code Interpreter, mathematical computations, and optimized execution
- 🏗️ 31-CrewAI-Engineering-Team AI Multi-Agent Software Engineering System with specialized agents, complete application development, and production-ready code generation
- 🤖 32-LangGraph-Chat Intelligent Chat System with LangGraph state management, graph-based workflows, and Gradio interface
- 🔍 33-LangGraph-Search Advanced AI Search System with web search, push notifications, persistent memory, and tool integration
- 🌐 34-LangGraph-Playwright Advanced Web Scraping System with anti-bot bypass, fresh browser contexts, and real-time content extraction
- 🤝 35-LangGraph-Sidekick Multi-Agent Personal Co-worker with Worker/Evaluator agents, structured outputs, and quality assurance loops
✈️ 36-AutoGen-Agent-Chat Multi-Agent Airline Assistant with Microsoft AutoGen, tool integration, database connectivity, and streaming responses- 🖼️ 37-AutoGen-Agent-Chat-Multi-Modal Multi-Modal Image Analysis System with vision capabilities, structured outputs, Pydantic validation, and OpenAI GPT-4o-mini integration
- 🔗 38-AutoGen-Agent-Chat-with-LangChain Multi-Agent Tool Integration System with LangChain tools, Google Serper search, file management, and advanced workflow orchestration
- � 39-AutoGen-Agent-Chat-RoundRobin Multi-Agent RoundRobin Conversation System with Microsoft AutoGen, iterative feedback loops, structured dialogue management, and approval-based termination
- �🔧 Enterprise-grade architecture and best practices
- 🧪 Comprehensive testing with pytest and modern testing frameworks
A cutting-edge HR platform leveraging Meta's Llama 3 70B for intelligent candidate screening
- AI Integration: Real-time candidate shortlisting using Groq API + Llama 3 70B
- Job Management: Complete CRUD operations for HR personnel
- Application Tracking: Comprehensive applicant workflow system
- File Management: Secure CV upload and processing with PDF validation
- Responsive Design: Mobile-optimized Bootstrap 5 interface
- Score-based Screening: AI-powered candidate scoring (0-100 scale)
- JSON Response Parsing: Structured AI responses with validation
# AI-powered candidate evaluation using Llama 3
def consult_ai(job, cv_path):
data = get_data(job=job, cv_path=cv_path)
client = Groq(api_key=os.environ.get('GROQ_API_KEY'))
completion = client.chat.completions.create(
model="llama3-70b-8192",
messages=[{
"role": "user",
"content": f"""You are an experienced HR assistant.
Given a resume, job responsibilities and required qualifications
you are supposed to rate that resume in a scale of 0 to 100 percent
return your response in a python dictionary format with score and summary as keys"""
}]
)
return parse_ai_response(response)- Backend: Django 4.2, Django ORM
- AI/ML: Groq API, Meta Llama 3 70B, pypdf for CV processing
- Frontend: Bootstrap 5, Purple Admin Template
- Database: SQLite (dev), PostgreSQL ready (prod)
- Testing: pytest, pytest-django
- Environment-based configuration with .env support
- Secure file upload handling with PDF validation
- Database migrations and model relationships
- Admin interface for HR operations
- RESTful API design patterns
- Score-based candidate shortlisting (≥80 threshold)
- JSON response validation and error handling
Modern SPA with secure JWT authentication and scalable architecture
- JWT Token System: Access/refresh token rotation
- Password Security: Django's built-in hashing
- CORS Configuration: Secure cross-origin requests
- Input Validation: Comprehensive data sanitization
// React frontend with secure API integration
const api = axios.create({
baseURL: 'http://localhost:8000/api',
headers: {
'Authorization': `Bearer ${getAccessToken()}`
}
});
// Automatic token refresh
api.interceptors.response.use(
response => response,
async error => {
if (error.response?.status === 401) {
await refreshAccessToken();
return api.request(error.config);
}
return Promise.reject(error);
}
);- Backend: Django REST Framework, Simple JWT
- Frontend: React 18, Vite, React Router
- UI: Tailwind CSS, Shadcn/ui, Lucide icons
- Testing: Vitest, React Testing Library
- Database: PostgreSQL production-ready
/api/user/register/- Secure user registration/api/token/- JWT token authentication/api/token/refresh/- Token rotation system- Protected routes with middleware authentication
A comprehensive meeting automation platform with real-time transcription, AI analysis, and multi-platform integration
- Real-time Transcription: OpenAI Whisper integration for live meeting transcription
- AI-Powered Analysis: GPT-4 for meeting summaries, action items, and sentiment analysis
- Multi-Platform Support: Zoom, Google Meet, and Teams integration via Playwright automation
- Bot Recorder: Automated meeting recording without requiring platform SDKs
- WebSockets: Live transcription streaming to connected clients
- OAuth Integration: Secure authentication with meeting platforms
- 100% Python: No Node.js or platform SDKs required
# AI-powered meeting processing with MCP
def transcribe_audio_tool(video_url: str) -> str:
"""Transcribe meeting audio using OpenAI Whisper"""
audio_path = download_video(video_url)
transcript = transcribe_audio(audio_path) # OpenAI Whisper
return transcript
def summarize_meeting_tool(transcript: str) -> str:
"""Generate meeting summary using GPT-4"""
summary = summarize_meeting(transcript) # GPT-4 analysis
actions = extract_action_items(transcript)
return {
"transcript": transcript,
"summary": summary,
"actions": actions
}
# Bot Recorder with Playwright
async def _join_with_playwright(self):
from playwright.async_api import async_playwright
playwright = await async_playwright().start()
browser = await playwright.chromium.launch()
# Automatically joins meeting without SDK- Backend: FastAPI, WebSockets, Playwright
- AI/ML: OpenAI Whisper, GPT-4, FastMCP
- Automation: Playwright browser automation (100% Python)
- Real-time: WebSockets for live transcription (
/ws/transcript/{meeting_id}) - Authentication: OAuth 2.0 for meeting platforms
- Architecture: 2-file system (MCP_SERVER.py + MEETING_API.py)
- Multi-threaded processing for concurrent meetings
- Secure file upload and processing
- Real-time WebSocket communication
- Comprehensive error handling and logging
- Production-ready deployment configuration
- No platform SDKs required (Playwright-based approach)
- OAuth integration with Zoom, Google Meet, Teams
Model Context Protocol (MCP) servers providing seamless integration with AI assistants like Claude Desktop, featuring advanced authentication and real-time data processing
- Dual Implementation: TypeScript and Python versions for different ecosystems
- MCP Protocol: JSON-RPC 2.0 communication via stdio
- Weather Data: Integration with National Weather Service API
- AI Assistant Integration: Works with Claude Desktop and Windsurf
- Real-time Data: Weather alerts and forecasts for any US location
- Cross-platform: Compatible with Windows, macOS, and Linux
- Advanced Authentication: OAuth 2.0 with Auth0 integration
- Cloudflare Workers: Production-ready deployment on serverless platform
- Remote MCP: Secure remote server connections with token management
- Context Engineering: Optimized token usage and context management
- Agent Skills: Multi-agent systems with specialized capabilities
# Python MCP Server with FastMCP
@mcp.tool(name="get-forecast")
async def get_forecast(latitude: float, longitude: float) -> str:
"""Get weather forecast for coordinates."""
url = f"{NWS_API_BASE}/points/{latitude},{longitude}"
data = await make_nws_request(url)
return format_forecast(data)
@mcp.tool(name="get-alerts")
async def get_alerts(state: str) -> str:
"""Get weather alerts for a US state."""
url = f"{NWS_API_BASE}/alerts/active/area/{state}"
data = await make_nws_request(url)
return format_alerts(data)- Python Version: FastMCP, httpx, uv package management
- TypeScript Version: Node.js, npm, TypeScript compilation
- Protocol: JSON-RPC 2.0 over stdio
- API Integration: National Weather Service REST API
- Authentication: OAuth 2.0, Auth0, JWT token management
- Deployment: Cloudflare Workers, serverless architecture
- Remote Access: mcp-remote CLI tool for secure connections
- Context Optimization: FastMCP 2.12.4+ with advanced features
- Multi-Agent: LangChain integration with agent orchestration
- Auth0 Integration: Complete OAuth 2.0 flow with PKCE
- Cloudflare Deployment: Serverless MCP servers with global distribution
- Remote Authentication: Secure token-based remote MCP connections
- Context Engineering: Optimized token usage for AI assistants
- Multi-Agent Systems: Specialized agents for different tasks
- Real-time Processing: WebSocket connections for live data
- Production Monitoring: Comprehensive logging and error handling
- Enterprise Security: Role-based access control and audit logging
An intelligent AI agent built with LangChain that generates realistic sample user data for applications and testing purposes, featuring natural language processing and structured JSON output generation.
- Natural Language Interface: Conversational commands for data generation using Google Gemini 2.5 Flash
- Structured JSON Output: Complete user profiles with ID, names, email, username, age, registration dates
- Smart Parameter Inference: Automatically fills in names, domains, and age ranges based on context
- File Operations: Read/write JSON files with proper formatting and validation
- Customizable Data: Control age ranges, email domains, specific names, and more
- Real-time Processing: Instant data generation with AI-powered understanding
- Production Ready: Error handling, logging, and comprehensive documentation
# AI-powered data generation with LangChain
@tool
def generate_sample_users(
first_names: List[str],
last_names: List[str],
domains: List[str],
min_age: int,
max_age: int
) -> dict:
"""Generate sample user data with complete profiles"""
users = []
for i in range(len(first_names)):
user = {
"id": i + 1,
"firstName": first_names[i],
"lastName": last_names[i % len(last_names)],
"email": f"{first_names[i].lower()}.{last_names[i % len(last_names)].lower()}@{domains[i % len(domains)]}",
"username": f"{first_names[i].lower()}{random.randint(100, 999)}",
"age": random.randint(min_age, max_age),
"registeredAt": (datetime.now() - timedelta(days=random.randint(1, 365))).isoformat()
}
users.append(user)
return {"users": users, "count": len(users)}
# Natural language processing with Google Gemini
llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash")
agent = create_agent(llm, TOOLS, system_prompt=SYSTEM_MESSAGE)- AI Framework: LangChain with Google Gemini 2.5 Flash integration
- Data Processing: Pydantic for validation, JSON for structured output
- Package Management: UV for modern Python dependency management
- Natural Language: Advanced prompt engineering for context understanding
- File Operations: JSON read/write with error handling and validation
- Architecture: Tool-based design with extensible function system
- Conversational interface for non-technical users
- Automatic parameter inference from natural language
- Comprehensive error handling and user feedback
- Extensible tool system for additional data types
- Production-ready logging and monitoring
- Complete documentation and examples
- Cross-platform compatibility (Windows, macOS, Linux)
# Start the agent
uv run main.py
# Natural language commands
You: generate 5 random users
You: make users aged 25-35 with company.com emails and save 3 of them to users.json
You: what is the oldest user in users.json?A sophisticated event-driven RAG application demonstrating modern AI integration patterns with Google Gemini, Inngest, Qdrant, and Streamlit for intelligent document processing and querying.
- Google Gemini 2.5 Flash Integration: Advanced LLM for intelligent responses with text-embedding-004
- Event-Driven Architecture: Scalable processing with Inngest for async workflows
- Vector Database: Qdrant for high-performance similarity search and storage
- Real-time Processing: Live PDF ingestion, chunking, and embedding generation
- Beautiful UI: Streamlit frontend for document upload and intelligent querying
- Semantic Search: Advanced embedding-based retrieval with source attribution
- Production Ready: Type safety, error handling, and comprehensive logging
# Event-driven PDF ingestion with Inngest
@inngest_client.create_function(
fn_id="RAG: Ingest PDF",
trigger=inngest.TriggerEvent(event="rag/ingest_pdf"),
)
async def rag_ingest_pdf(ctx: inngest.Context):
# Load and chunk PDF
chunks_and_src = await ctx.step.run("load-and-chunk", lambda: _load(ctx))
# Generate embeddings and store in Qdrant
ingested = await ctx.step.run("embed-and-upsert", lambda: _upsert(chunks_and_src))
return ingested.model_dump()
# Intelligent querying with context
@inngest_client.create_function(
fn_id="RAG: Query PDF",
trigger=inngest.TriggerEvent(event="rag/query_pdf_ai"),
)
async def rag_query_pdf_ai(ctx: inngest.Context):
# Embed question and search vectors
found = await ctx.step.run("embed-and-search", lambda: _search(question, top_k))
# Generate contextual response with Gemini
answer = await ctx.step.run("llm-answer", lambda: _generate_answer(user_content))
return {"answer": answer, "sources": found.sources}- AI/ML: Google Gemini 2.5 Flash, text-embedding-004 (768 dimensions)
- Backend: FastAPI with async/await, Inngest for event-driven processing
- Vector DB: Qdrant for similarity search and vector storage
- Frontend: Streamlit for beautiful, responsive web interface
- Package Management: UV for modern Python dependency management
- Architecture: Event-driven microservices with type safety
- Multi-terminal architecture (FastAPI + Inngest + Qdrant + Streamlit)
- Real-time PDF processing with automatic chunking and embedding
- Semantic search with configurable retrieval parameters
- Comprehensive error handling and status monitoring
- Type-safe implementation with Pydantic models
- Hot reloading for fast development cycles
- Docker-ready deployment configuration
# Terminal 1: Start Qdrant vector database
docker run -d --name qdrant-rag -p 6333:6333 qdrant/qdrant:latest
# Terminal 2: Start FastAPI backend with Inngest
uv run uvicorn main:app --reload
# Terminal 3: Start Inngest dev server
npx inngest-cli@latest dev -u http://127.0.0.1:8000/api/inngest
# Terminal 4: Start Streamlit frontend
uv run streamlit run streamlit_app.py
# Use the web interface at http://localhost:8501
# Upload PDFs and ask intelligent questions about your documentsAn intelligent multi-source research agent that leverages multiple search engines and social media platforms to provide comprehensive, well-analyzed answers to user queries.
- Multi-Source Intelligence: Google, Bing, and Reddit search with unified analysis
- Bright Data Integration: Professional-grade web scraping with SERP and Reddit APIs
- LangGraph Workflow: Complex multi-step research orchestration with state management
- Google Gemini AI: Advanced reasoning and synthesis from multiple data sources
- Structured Data Processing: Pydantic models for type-safe data handling
- Real-time Progress Tracking: Asynchronous snapshot polling and download management
- Comprehensive Analysis: Individual source analysis with final intelligent synthesis
# Multi-source search orchestration with LangGraph
def search_google(state: State):
query = state.get("user_question", "")
google_results = serp_search(query, engine="google")
return {"google_results": google_results}
def search_bing(state: State):
query = state.get("user_question", "")
bing_results = serp_search(query, engine="bing")
return {"bing_results": bing_results}
def search_reddit(state: State):
query = state.get("user_question", "")
reddit_results = reddit_search_api(query)
return {"reddit_results": reddit_results}
# AI-powered URL selection and content extraction
def analyze_reddit_urls(state: State):
reddit_results = state.get("reddit_results", "")
messages = get_reddit_url_analysis_messages(reddit_results)
structured_llm = llm.with_structured_output(RedditURLAnalysis)
analysis = structured_llm.invoke(messages)
return {"selected_reddit_urls": analysis.selected_urls}- AI Framework: LangChain with Google Gemini 2.5 Flash integration
- Workflow Orchestration: LangGraph for complex multi-step processes
- Web Scraping: Bright Data SERP API and Reddit Datasets API
- Data Processing: Pydantic models, structured outputs, JSON handling
- Package Management: UV for modern Python dependency management
- Architecture: State-based workflow with parallel processing
- Parallel multi-source data collection for faster results
- Configurable retry logic and timeout handling for API reliability
- Intelligent URL selection using structured LLM outputs
- Comprehensive error handling with graceful degradation
- Real-time progress tracking and user feedback
- Type-safe implementation with full Pydantic validation
- Extensible architecture for additional search sources
# Setup and run the multi-source research agent
cd 22-AI-Search-Agent
uv sync
cp .env.example .env
# Edit .env with Bright Data and Google API keys
uv run main.py
# Example research queries
Ask me anything: invest in NVIDIA
Ask me anything: best programming languages for AI development
Ask me anything: climate change impact on technologyA sophisticated AI career assistant powered by Google Gemini models with advanced multi-model rotation, session tracking, and comprehensive API management system.
- Multi-Model AI Chat: Intelligent conversation using Google's free Gemini models
- 4-Model Rotation System: Automatic switching between gemini-2.5-flash, gemini-2.0-flash, gemini-2.5-flash-lite, and gemini-2.0-flash-lite
- Smart Rate Limiting: Exponential backoff with automatic retry logic (1min → 30min)
- Session Tracking: UUID-based session tracking for user interaction analytics
- Real-time Notifications: Pushover integration with complete API usage statistics
- Career Showcase: Displays Daniel's 12+ years of software development expertise
- Smart Tool Integration: Automatic detection of unknown questions, contact requests, and job offers
# Advanced API Management with Multi-Model Rotation
class APIKeyModelManager:
def __init__(self):
self.keys = self._load_api_keys()
self.models = FREE_MODELS # 4 Gemini models
self.usage_per_combination = {} # Track per (key, model) usage
def increment_usage(self):
"""Increment usage for current key and model combination"""
combo = (self.current_key_index, self.current_model_index)
if combo not in self.usage_per_combination:
self.usage_per_combination[combo] = 0
self.usage_per_combination[combo] += 1
def get_usage_stats(self):
"""Display real-time usage statistics per model+key combination"""
# Shows per-model usage with proper reset on model switch
return comprehensive_usage_display
# Session-aware tool calling with tracking
def handle_tool_call(self, tool_calls):
results = []
for tool_call in tool_calls:
tool_name = tool_call.function.name
arguments = json.loads(tool_call.function.arguments)
# Add session_id to all tool calls for tracking
arguments['session_id'] = self.session_id
tool = globals().get(tool_name)
result = tool(**arguments) if tool else {}
results.append({
"role": "tool",
"content": json.dumps(result),
"tool_call_id": tool_call.id
})
return resultsMulti-Model Rotation Logic:
- gemini-2.5-flash: Best quality, hybrid reasoning, 1M context
- gemini-2.0-flash: Multimodal, agent-ready, 1M context
- gemini-2.5-flash-lite: Cost-effective, high throughput
- gemini-2.0-flash-lite: Fastest, most economical
Session Management:
# UUID-based session tracking
self.session_id = str(uuid.uuid4())
# Enhanced push notifications with session context
def push(text, session_id=None, user_context=None):
full_message = text + "\n\n" + "="*40
full_message += f"\n📍 Session ID: {session_id[:8]}..."
full_message += f"\n• Timestamp: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
full_message += f"\n\n🔑 Gemini API Usage:\n{api_manager.get_usage_stats()}"Intelligent Tool Detection:
record_unknown_question: Captures questions outside Daniel's expertiserecord_user_details: Handles contact information and networking requestsrecord_job_offer: Processes job opportunities with compensation details
🤖 Current Model: gemini-2.5-flash
🔑 Current Key: 3
Key 1: 20/20 used ⚠️ (1/4 models exhausted) (resets in 23h 59m)
Key 2: 15/20 used ✅
Key 3: 3/20 used ✅
Key 4: 0/20 used ✅
API Management:
- Per-model usage tracking: Independent counters for each model+key combination
- Automatic rotation: Seamless switching when quotas are exhausted
- Backoff strategy: Exponential backoff for rate limit handling
- Error recovery: Comprehensive error handling with automatic retry
Professional Applications:
- Career Networking: Automated response to professional inquiries
- Job Opportunity Detection: Immediate notification of relevant positions
- Knowledge Gap Analysis: Identify topics to expand expertise
- Business Development: Lead capture and qualification system
# Setup and run the advanced AI career assistant
cd 24-AI-Career-Assistant
uv sync
cp .env.example .env
# Edit .env with 4 Google Gemini API keys and Pushover credentials
uv run daniel-chatbot.py
# Available at http://127.0.0.1:7860 or https://[random-id].gradio.live
# Example interactions:
# "What experience do you have with AI and blockchain development?"
# "I'm recruiting for a senior Python position at JP Morgan"
# "Can you help me understand your consulting rates and availability?"- Multi-API Key Management: Load balancing across 4 Gemini API keys
- Session Analytics: Complete interaction tracking with UUID-based sessions
- Real-time Monitoring: Live usage statistics and API quota management
- Professional Branding: Tailored for Daniel's 12+ years software development experience
- Mobile Notifications: Instant alerts with comprehensive usage analytics
A sophisticated multi-model AI agent system leveraging OpenAI Agents SDK for automated sales development representative (SDR) workflows with intelligent model rotation and complete email automation pipeline.
- Multi-Model AI Agents: DeepSeek, Gemini, Llama3.3, and OpenAI models with intelligent fallback rotation
- Automated Email Generation: Three specialized email styles (professional, humorous, concise) with real-time generation
- Smart Model Rotation: 4-attempt fallback system (Primary → OpenAI → Other1 → Other2) with comprehensive error handling
- Complete Email Workflow: Generation → Selection → Subject Writing → HTML Conversion → Email Sending
- Input Guardrails: Advanced name detection and validation system for security compliance
- Real-time Tracing: Full OpenAI dashboard visibility for all model attempts and executions
- Resend Integration: Professional email delivery with HTML formatting and delivery confirmation
- Enterprise Error Handling: Graceful handling of API failures (402, 403, 429) with automatic retry logic
# Multi-model rotation with real execution and tracing
async def _run_agent_with_rotation(tool_name: str, instructions: str, input_text: str, model_sequence: list) -> str:
"""Try each model in sequence until one succeeds. Each attempt appears in traces."""
for i, (model, model_name) in enumerate(model_sequence):
try:
print(f" 🔄 [{tool_name}] Attempt {i+1}/4: Trying {model_name}...")
agent = Agent(name=f"{model_name} Sales Agent", instructions=instructions, model=model)
result = await Runner.run(agent, input_text) # Real model execution
print(f" ✅ [{tool_name}] {model_name} succeeded!")
return result.final_output
except Exception as e:
print(f" ❌ [{tool_name}] {model_name} failed: {str(e)[:80]}")
continue # Rotate to next model
# Input guardrails for security
@input_guardrail
async def guardrail_against_name(ctx, agent, message):
result = await Runner.run(guardrail_agent, message, context=ctx.context)
is_name_in_message = result.final_output.is_name_in_message
return GuardrailFunctionOutput(
output_info={"found_name": result.final_output},
tripwire_triggered=is_name_in_message
)- AI Framework: OpenAI Agents SDK with multi-model support
- Models: DeepSeek, Gemini, Llama3.3, OpenAI gpt-4o-mini with rotation logic
- Email Service: Resend API with HTML formatting and delivery tracking
- Security: Input guardrails with name detection and validation
- Monitoring: Real-time tracing with OpenAI dashboard integration
- Package Management: UV for modern Python dependency management
Model Rotation Strategy:
# Each tool attempts models in different orders for diversity
TOOL1: DeepSeek → OpenAI → Gemini → Llama3.3
TOOL2: Gemini → OpenAI → Llama3.3 → DeepSeek
TOOL3: Llama3.3 → OpenAI → DeepSeek → GeminiComplete Workflow:
- Input Validation: Guardrail agent checks for personal information
- Email Generation: 3 sales agents create different style drafts
- Model Rotation: Each agent tries 4 models until success
- Selection: Sales Manager selects best email draft
- Email Processing: Subject writing + HTML conversion
- Delivery: Email sent via Resend with confirmation
Error Handling:
- 402 Insufficient Balance: Automatic rotation to next model
- 403 Access Denied: Seamless transition to backup model
- 429 Rate Limit: Intelligent retry with exponential backoff
- Max Turns Exceeded: Fallback to next Sales Manager model
# Setup and run the multi-model automated SDR system
cd 25-openai-agent
uv sync
cp .env.example .env
# Edit .env with API keys (OpenAI, Google, DeepSeek, Groq, Resend)
uv run main.py
# Example output with model rotation:
🔄 [TOOL1] Starting multi-model rotation (DeepSeek -> OpenAI -> Gemini -> Llama3.3)
🔄 [TOOL1] Attempt 1/4: Trying DeepSeek...
❌ [TOOL1] DeepSeek failed: Error code: 402 - Insufficient Balance
🔄 [TOOL1] Attempt 2/4: Trying OpenAI...
✅ [TOOL1] OpenAI succeeded!
✅ [SALES_MGR] Handoff successful! Sales Manager → Email Manager
📧 [SALES_MGR] Email should have been processed and sent by Email Manager- Multi-API Management: Load balancing across 4 different AI providers
- Real-time Monitoring: Complete visibility into model attempts and success rates
- Security Compliance: Input validation with guardrail protection
- Production Logging: Comprehensive error tracking and performance metrics
- Email Automation: Professional delivery with HTML formatting and tracking
A sophisticated multi-agent debate system powered by CrewAI that simulates structured debates on complex topics with AI agents taking different positions and providing objective analysis.
- Multi-Agent Architecture: Three specialized AI agents (Pro-Regulation, Anti-Regulation, Moderator)
- Structured Debate Flow: Opening arguments → Context-aware rebuttals → Final analysis
- Real-time Tracing: Built-in execution tracing with CrewAI Cloud integration
- Customizable Topics: Easy to modify debate subjects and agent configurations
- Context-Aware Responses: Agents reference previous arguments in rebuttals
- Objective Moderation: Independent moderator evaluates both sides comprehensively
# Crew orchestration with sequential process
crew = Crew(
agents=[pro_agent, anti_agent, moderator],
tasks=[pro_task, anti_task, pro_rebuttal, anti_rebuttal, moderator_task],
process=Process.sequential,
verbose=True
)
# Execute debate with real-time tracing
result = crew.kickoff()- Framework: CrewAI 1.8+ with multi-agent orchestration
- AI/ML: OpenAI GPT models (gpt-4o-mini, gpt-4, etc.)
- Configuration: YAML-based agent and task definitions
- Tracing: CrewAI Cloud integration for debugging and monitoring
- Package Management: UV with Python 3.12 compatibility
-
Opening Arguments (300-400 words each)
- Pro-regulation advocate presents comprehensive case
- Anti-regulation advocate presents counter-arguments
-
Context-Aware Rebuttals (200-300 words each)
- Each agent addresses specific points from opposition
- Builds upon previous arguments with evidence
-
Final Analysis (400-500 words)
- Moderator evaluates both sides objectively
- Identifies strongest arguments and logical fallacies
- Provides balanced conclusion
# Setup CrewAI CLI with Python 3.12
uv tool install crewai --python 3.12
# Create and setup project
crewai create crew debate-ai
cd debate-ai
crewai install
# Configure environment
cp .env.example .env
# Edit .env with OPENAI_API_KEY
# Run structured debate
crewai run
# Enable tracing for debugging
crewai traces enable- Extensible Architecture: Add more agents and debate topics
- Knowledge Integration: Support for external knowledge bases
- Real-time Monitoring: Complete visibility into agent interactions
- Custom LLM Support: Compatible with OpenAI, Anthropic, Groq, and more
- YAML Configuration: Easy modification of agents and tasks without code changes
The system generates comprehensive debate outputs:
- Structured Arguments: Evidence-based positions with clear reasoning
- Intelligent Rebuttals: Context-aware responses to opposition points
- Objective Analysis: Balanced evaluation with identification of logical fallacies
- Trace Reports: Detailed execution logs for debugging and improvement
A sophisticated financial research and analysis system powered by CrewAI that provides up-to-date company analysis using real-time web searches and professional financial reporting.
- Real-Time Data Integration: Live stock prices, recent news, earnings reports, and market analysis via SerperDevTool
- Multi-Agent Architecture: Senior Financial Researcher (web search specialist) and Market Analyst (report generation)
- Professional Financial Reporting: Structured reports with executive summary, current status, developments, analysis, and outlook
- Source Verification: All data includes citations and publication dates for credibility
- Date-Specific Context: Every data point includes temporal information for accuracy
# Financial research with real-time web searches
class FinancialResearcher:
@agent
def researcher(self) -> Agent:
return Agent(
config=self.agents_config['researcher'],
tools=[SerperDevTool()], # Real-time web search
verbose=True
)
def run(self):
inputs = {
'company': 'Tesla',
'year': datetime.now().year # Current year
}
return self.crew().kickoff(inputs=inputs)- Framework: CrewAI 1.8+ with multi-agent orchestration
- AI/ML: OpenAI GPT models for analysis and reporting
- Real-Time Search: SerperDevTool for live financial data and news
- Configuration: YAML-based agent and task definitions with mandatory search queries
- Output Generation: Professional markdown reports with source citations
-
Mandatory Web Searches: Research agent performs 5 required searches:
"{company} stock price {year}""{company} earnings report {year}""{company} news {year}""{company} financial results {year}""{company} market analysis {year}"
-
Data Collection: Gathers current financial data, stock prices, recent news
-
Professional Analysis: Creates comprehensive report with insights and projections
# Setup CrewAI CLI with Python 3.12
uv tool install crewai --python 3.12
# Create and setup project
crewai create crew financial-researcher
cd financial-researcher
crewai install
# Configure environment
cp .env.example .env
# Edit .env with OPENAI_API_KEY and SERPER_API_KEY
# Run financial analysis
crewai run
# Output: Comprehensive financial report with current data
# Tesla Company Analysis Report - 2026
# - Stock Price: $437.86 (as of January 16, 2026)
# - Recent Financial Results: 589,000 vehicles delivered in 2025
# - Market Analysis: Current analyst projections and trends- Customizable Companies: Analyze any publicly traded company
- Year-Specific Analysis: Focus on current year or historical periods
- Extensible Search: Add custom search queries for specific financial data
- Professional Formatting: Structured markdown reports with proper citations
- Real-Time Verification: All data includes sources and publication dates
The system generates professional financial reports with:
- Current Data: Real-time stock prices and market metrics
- Recent News: Latest announcements and developments
- Financial Analysis: Professional insights and trend analysis
- Source Citations: All data includes sources and dates
- Future Projections: Analyst expectations and market outlook
- Error Handling: Graceful handling of API limits and search failures
- Data Validation: Verification of financial data accuracy and recency
- Professional Output: Structured reports suitable for business use
- Extensible Architecture: Easy to add new search queries and analysis types
A sophisticated multi-agent AI system powered by CrewAI that performs comprehensive financial analysis, identifies trending companies, and makes data-driven investment recommendations with real-time market intelligence and persistent learning capabilities.
- Multi-Agent Architecture: Manager orchestrates Financial News Analyst, Senior Financial Researcher, and Stock Picker agents
- Advanced Memory Systems: Short-term, long-term, and entity memory with ChromaDB vector storage and SQLite persistence
- Hierarchical Process: Manager delegates tasks and coordinates workflow for optimal decision-making
- Real-Time Market Intelligence: SerperDevTool integration for live web searches and current market data
- Smart Notifications: Instant investment recommendations via Pushover with custom branding (📈 AI Stock Picker)
- Professional Output Generation: JSON reports with structured data and markdown decisions with detailed rationale
# Advanced memory systems for persistent learning
class StockPicker:
@crew
def crew(self) -> Crew:
manager = Agent(
config=self.agents_config['manager'],
allow_delegation=True
)
return Crew(
agents=self.agents,
tasks=self.tasks,
process=Process.hierarchical, # Manager coordination
memory=True,
short_term_memory=short_term_memory, # ChromaDB embeddings
long_term_memory=long_term_memory, # SQLite persistence
entity_memory=entity_memory, # Entity extraction
manager_agent=manager
)- Framework: CrewAI 1.8+ with hierarchical multi-agent orchestration
- AI/ML: OpenAI GPT models for analysis and decision-making
- Memory Systems: ChromaDB (vector embeddings) + SQLite (structured persistence)
- Real-Time Search: SerperDevTool for live financial data and market intelligence
- Notifications: Pushover API for instant investment recommendations
- Data Processing: Pydantic models for structured JSON validation
Three-Layer Memory System:
- Short-Term Memory: ChromaDB with OpenAI embeddings for recent conversations
- Long-Term Memory: SQLite database for persistent knowledge and historical insights
- Entity Memory: Vector embeddings for companies, relationships, and semantic connections
Learning Benefits:
- Session 1: Analyzes Tesla → Stores EV market insights
- Session 2: Analyzes Rivian → Recalls Tesla patterns for comparison
- Session 3: Analyzes Lucid → Compares with all previous EV analysis
- Trending Company Discovery: Real-time news search for current market trends
- Deep Financial Research: Company-specific analysis with market position and outlook
- Investment Decision Making: Comparative analysis with risk-adjusted selection
- Instant Notification: Push notification with decision and rationale
# Setup CrewAI CLI with Python 3.12
uv tool install crewai --python 3.12
# Create and setup project
crewai create crew stock-picker
cd stock-picker
crewai install
# Configure environment
cp .env.example .env
# Edit .env with OPENAI_API_KEY, SERPER_API_KEY, PUSHOVER_USER, PUSHOVER_TOKEN
# Run investment analysis
crewai run
# Output: Comprehensive investment analysis with memory-enhanced insights
# 📱 Push Notification: 📈 AI Stock Picker - Perplexity AI selected for investment
# 📊 Files: trending_companies.json, research_report.json, decision.md- Persistent Learning: Memory systems learn from each analysis session
- Hierarchical Management: Manager coordinates agent delegation and quality control
- Real-Time Intelligence: Live market data with current year context
- Entity Recognition: Automatic extraction of companies and relationships
- Investment Tracking: Historical decision analysis and performance comparison
- Customizable Sectors: Analyze any market sector (Technology, Healthcare, etc.)
The system generates comprehensive investment analysis:
- Trending Companies: JSON list with current market trends and reasoning
- Research Reports: Detailed financial analysis with market position and outlook
- Investment Decisions: Rationale for selection and rejected alternatives
- Memory-Enhanced Insights: Comparisons with previous analyses and learned patterns
- Error Handling: Robust JSON validation and trailing comma prevention
- Memory Management: Efficient ChromaDB and SQLite storage systems
- Data Validation: Source verification and citation requirements
- Scalable Architecture: Modular agent and task configuration
- Professional Output: Investment-grade analysis with structured reporting
A sophisticated multi-agent AI system powered by CrewAI that generates, executes, and validates Python code with real-time Docker-based code interpretation, optimized for computational tasks and mathematical calculations.
- Docker Code Interpreter: Secure code execution in isolated Docker containers with automatic lifecycle management
- Optimized Performance: 120-second execution window with retry logic and comprehensive error handling
- Intelligent Code Generation: Natural language to Python code conversion with mathematical computation capabilities
- Professional Output Management: Structured results with file generation and execution tracing
@agent
def coder(self) -> Agent:
return Agent(
config=self.agents_config['coder'],
verbose=True,
allow_code_execution=True, # Enables Code Interpreter
code_execution_mode="safe", # Uses Docker containers
max_execution_time=120, # Optimized timeout
max_retry_limit=5, # Retry failed executions
)- Framework: CrewAI 1.8+ with code execution capabilities
- AI/ML: OpenAI GPT models for code generation and problem solving
- Docker Integration: Secure containerized code execution environment
- Performance: Optimized timeout management and retry mechanisms
- Output Management: Structured code generation with execution results
Secure Execution Environment:
- Code runs in isolated Docker containers
code_execution_mode="safe"ensures complete system isolation- Automatic container lifecycle management
- Cross-platform compatibility and consistency
Performance Features:
- 120-second execution window for intensive calculations
- Up to 5 retry attempts for failed executions
- Comprehensive timeout and error management
- Detailed execution traces and performance monitoring
Mathematical Series Calculation:
# Generated code for π approximation
total = 0.0
for n in range(10000):
if n % 2 == 0:
total += 1 / (2 * n + 1)
else:
total -= 1 / (2 * n + 1)
result = total * 4
print(result) # Output: 3.1414926535900345# Setup CrewAI CLI with Python 3.12
uv tool install crewai --python 3.12
# Create and setup project
crewai create crew crewai-coder
cd crewai-coder
crewai install
# Configure environment
cp .env.example .env
# Edit .env with OPENAI_API_KEY and CREWAI_TRACING_ENABLED=true
# Run code generation
crewai run
# Output: Complete Python code with execution results
# 🐳 Docker: Running code in Docker environment...
# 📊 Result: 3.1414926535900345 (π approximation)- Natural Language to Code: Convert programming descriptions into executable Python
- Mathematical Computing: Handle complex calculations and series approximations
- Secure Execution: Docker-based isolation for code safety
- Performance Optimization: Configurable timeouts and retry mechanisms
- Cross-Platform: Consistent behavior across operating systems
- Series Approximation: 10,000 terms in <30 seconds
- Docker Startup: ~2-3 seconds container initialization
- Memory Management: Efficient resource usage in containers
- Error Recovery: Automatic retry logic for failed executions
- Secure Execution: Docker-based isolation for code safety
- Performance Monitoring: Detailed execution timing and resource usage
- Error Handling: Comprehensive timeout and failure management
- Scalable Design: Modular configuration for different coding tasks
- Professional Output: Production-ready code generation and validation
| Project | Skills Demonstrated | Complexity |
|---|---|---|
| Printing & Variables | String formatting, type conversion, f-strings | ⭐ |
| Data Types & Type System | Primitive types, operators, type casting | ⭐⭐ |
| Tip Calculator | Mathematical operations, user input, business logic | ⭐⭐ |
| Treasure Island Game | Conditional logic, control flow, game development | ⭐⭐⭐ |
| Rock-Paper-Scissors | Randomization, arrays, game logic, ASCII art | ⭐⭐⭐ |
| Password Generator | Loops, string manipulation, security concepts | ⭐⭐⭐ |
| Project | Technical Skills | Applications |
|---|---|---|
| Hangman Game | ASCII art, word lists, game state management | Game Development |
| Caesar Cipher | Encryption/decryption, modular arithmetic, text processing | Cryptography |
| Dictionary Mastery | Data structures, JSON-like operations, complex data handling | Data Management |
| Function Design | Return values, scope management, modular programming | Software Architecture |
| Testing & Debugging | pytest, error handling, code validation | Quality Assurance |
| Scope Management | Local/global variables, memory management, best practices | System Design |
- Clean Code Principles: PEP 8 compliance, descriptive naming, modular design
- Testing Methodology: Unit tests, integration tests, TDD concepts
- Version Control: Git workflow, branching strategies, collaborative development
- Documentation: Comprehensive READMEs, code comments, API documentation
- MVC/MVT Patterns: Django's Model-View-Template architecture
- RESTful Design: Proper HTTP methods, status codes, resource modeling
- Database Design: Relational modeling, migrations, ORM optimization
- Security Implementation: Authentication, authorization, data validation
- Environment Management: Virtual environments, dependency isolation
- Configuration Management: Environment variables, settings separation
- API Development: REST standards, serialization, error handling
- Frontend Integration: CORS, JWT, modern JavaScript/React patterns
- LLM Integration: Groq API, prompt engineering, response parsing
- Real-time Processing: Asynchronous operations, error handling
- Data Processing: File handling, PDF processing, text analysis
- Scalable AI Architecture: Modular design for AI features
A sophisticated chat application built with LangGraph that demonstrates state management, graph-based agent workflows, and real-time conversational AI capabilities.
- 🔄 StateGraph Architecture: Graph-based agent workflow with state management
- 💬 Interactive Chat Interface: Gradio-powered real-time chat UI
- �� Message Processing: LangChain message types and validation
- 📊 Graph Visualization: Mermaid diagram generation and PNG export
- ⚡ Real-time Processing: Asynchronous message handling and response generation
class State(BaseModel):
message: Annotated[list, add_messages]
def our_first_node(old_state: State) -> State:
reply = f"{random.choice(nouns)} are {random.choice(adjectives)}"
messages = [{"role": "assistant", "content": reply}]
return State(message=messages)
graph = graph_builder.compile()- Framework: LangGraph for graph-based agent workflows
- AI/ML: LangChain for message handling and validation
- Frontend: Gradio for web-based chat interface
- State Management: Pydantic models with annotated types
- Visualization: Mermaid diagrams and PNG export
Graph-Based Processing:
- User Input → Gradio ChatInterface receives message
- State Creation → LangGraph State with message history
- Graph Processing → Node processes and generates response
- Response Return → AI message delivered to user
- Response Time: <50ms for message processing
- Graph Compilation: <100ms for workflow setup
- UI Rendering: <200ms for interface load
- Memory Usage: ~50MB baseline with minimal spikes
State-of-the-Art Architecture:
- LangGraph's StateGraph for complex agent orchestration
- Automatic message state management with type safety
- Visual graph representation for workflow debugging
- Modular node system for easy expansion
Developer Experience:
- UV-based dependency management for modern Python workflows
- Comprehensive error handling and validation
- Real-time debug information and graph visualization
- Extensible architecture for future enhancements
- OpenAI Integration: GPT-4 powered intelligent responses
- Memory System: Persistent conversation history
- Multi-Graph Support: Multiple specialized agents
- Voice Interface: Speech-to-text and text-to-speech
- Database Integration: PostgreSQL/MongoDB for persistence
A revolutionary multi-agent AI system powered by CrewAI that orchestrates specialized engineering agents to design, develop, test, and deploy complete Python applications from start to finish.
- 🤖 Specialized Multi-Agent System: 4 expert agents with distinct roles (Engineering Lead, Backend Engineer, Frontend Engineer, Test Engineer)
- 🔄 Complete Development Pipeline: Sequential workflow from requirements to production-ready code
- 💻 Full-Stack Generation: Backend Python code with Gradio UI frontend
- 🧪 Automated Testing: Complete unit test suites with edge case validation
- ⚡ Optimized Model Configuration: OpenAI models balanced for cost and quality
@agent
def engineering_lead(self) -> Agent:
return Agent(
config=self.agents_config["engineering_lead"],
verbose=True,
allow_code_execution=True,
max_execution_time=240,
)- Framework: CrewAI 1.8+ with multi-agent orchestration
- AI/ML: OpenAI GPT-4 Turbo, GPT-4o, GPT-4o-mini for optimized performance
- Frontend: Gradio for rapid UI development
- Testing: Python unittest framework with comprehensive coverage
- Code Execution: Docker-based secure code execution environment
Multi-Agent Workflow:
- Engineering Lead: Creates detailed system design and architecture
- Backend Engineer: Implements complete Python backend with business logic
- Frontend Engineer: Develops Gradio UI with full integration
- Test Engineer: Generates comprehensive unit tests with edge cases
Generated Application Example:
# Complete Trading System Generated
class Account:
def __init__(self, username, initial_deposit):
# Full implementation
def buy_shares(self, symbol, quantity):
# Trading logic with validation- Execution Time: 3-8 minutes for complete application generation
- Cost Efficiency: ~$0.50-1.50 per complete application
- Success Rate: 100% functional applications with proper error handling
- Test Coverage: 17+ unit tests per application with edge case validation
- 🏦 Financial Systems: Trading platforms, portfolio management, investment simulators
- 🛒 E-commerce: Inventory systems, payment processing, shopping carts
- 📊 Data Analytics: Interactive dashboards, reporting tools, data visualization
- 🎮 Gaming: Strategy games, business simulators, scoring systems
Enterprise-Ready Code Generation:
- Production-ready Python applications with proper error handling
- Complete UI/UX with Gradio interface
- Comprehensive testing with 100% feature coverage
- Scalable architecture following industry best practices
Cost-Effective Development:
- Reduces development time from days to minutes
- Optimized model selection for cost efficiency
- Automated testing eliminates manual QA efforts
- Consistent code quality across all generated applications
A sophisticated multi-agent research system leveraging OpenAI Agents SDK for automated deep research with web search capabilities, real-time streaming, and comprehensive report generation.
- Multi-Agent Architecture: Specialized agents for planning, searching, writing, and email delivery
- Real-time Web Search: Integration with OpenAI WebSearchTool for up-to-date information
- Streaming Interface: Gradio-based UI with real-time progress updates
- Automated Reporting: AI-powered report generation with markdown formatting
- Email Integration: Automatic email delivery of research results via Resend API
- Trace Monitoring: OpenAI platform integration for debugging and monitoring
# Multi-agent coordination with streaming
async def run(query: str):
async for chunk in ResearchManager().run(query):
yield chunk # Real-time UI updates
# Specialized agent workflow
1. Planner Agent → Research strategy
2. Search Agent → Web information gathering
3. Writer Agent → Report synthesis
4. Email Agent → Automated delivery- AI Framework: OpenAI Agents SDK (v0.6.4+)
- UI Framework: Gradio (v6.3.0) with streaming support
- Web Search: OpenAI WebSearchTool integration
- Email Service: Resend API for automated delivery
- Package Management: UV for modern Python dependency management
- Environment: Python 3.14+ with async/await patterns
# Clone and setup
git clone <repository>
cd 26-Deep-Research/deep_research
# Install dependencies
uv sync
# Configure environment
cp .env.example .env
# Edit .env with your API keys
# Run the research UI
uv run deep_research.py
# Or run CLI version
cd .. && uv run main.py- Concurrent Search: Parallel web searches with asyncio
- Intelligent Planning: AI-driven research strategy generation
- Error Handling: Robust exception management and fallbacks
- Real-time Tracing: OpenAI platform integration for debugging
- Modular Design: Extensible agent architecture for customization
- Interactive Interface: Clean Gradio UI with real-time updates
- Progress Tracking: Live status updates during research process
- Report Export: Markdown-formatted research reports
- Email Notifications: Automatic delivery to specified recipients
Python: 3.8+
Django: 4.2
Django REST Framework: Latest
PostgreSQL: Production Ready
SQLite: Development
JWT: Simple JWT
Testing: pytest, pytest-djangoReact: 18.2
Vite: Latest
Tailwind CSS: 3.4+
Shadcn/ui: Modern component library
Axios: HTTP client
React Router: Client-side routing
Testing: Vitest, React Testing LibraryLLM: Meta Llama 3 70B
API: Groq Cloud Platform
Prompt Engineering: Custom implementations
Text Processing: NLP fundamentalsVersion Control: Git
Environment: Python venv
Package Management: pip, npm
Code Quality: ESLint, PEP 8
Debugging: Django Debug Toolbar- 50+ Python programs with increasing complexity
- 5 production-ready applications with enterprise features
- Comprehensive test coverage across all major projects
- Documentation-first approach with detailed READMEs
- Multi-language implementations (Python, TypeScript, JavaScript)
- Multi-tier architecture (Frontend, Backend, AI services)
- Real-time AI integration with production APIs
- Security-first implementation with JWT and data validation
- Scalable design patterns for enterprise applications
- MCP Protocol implementation for AI assistant integration
- OAuth 2.0 authentication with Auth0 and enterprise security
- Cloudflare Workers deployment for global serverless architecture
- Remote MCP connections with secure token management
- Context engineering optimization for AI efficiency
- Multi-agent systems with specialized task capabilities
- Real-time communication with WebSockets and stdio protocols
- Cross-platform automation with Playwright browser control
- Multi-language development (Python, TypeScript, JavaScript)
- Enterprise-grade monitoring and logging systems
- Systematic skill building from basics to advanced concepts
- Project-based learning with real-world applications
- Modern tech stack aligned with industry standards
- Continuous improvement with refactoring and optimization
# Python Environment
Python 3.8+
pip (latest)
virtualenv
# Node.js Environment (for React projects)
Node.js 16+
npm or yarn# Clone the repository
git clone https://github.com/DanielGeek/python_projects.git
cd python_projects
# Explore daily exercises
ls 0*-day-*/
# Run flagship projects
cd 13-AIHR # AI-Powered HR System
# or
cd 14-Django-React-Full-Stack-App # Full-Stack App
# or
cd 16-MCP-meetings # AI-Powered Meeting System
# or
cd 17-mcp-servers # MCP Weather Servers
# or
cd 18-AI-agent # AI Data Generator Agent
# or
cd 21-RAG-AI # Advanced RAG System
# or
cd 25-openai-agent # OpenAI Agents Automated SDR Systemcd 13-AIHR
python -m venv venv
source venv/bin/activate # Windows: venv\Scripts\activate
pip install -r requirements.txt
python manage.py migrate
python manage.py runserver# Backend
cd 14-Django-React-Full-Stack-App/backend
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
python manage.py migrate
python manage.py runserver
# Frontend (new terminal)
cd ../frontend
npm install
npm run devcd 16-MCP-meetings
uv sync
source .venv/bin/activate
# Terminal 1: MCP Server (AI processing)
uv run MCP_SERVER.py
# Terminal 2: Meeting API (orchestrator)
uv run MEETING_API.py# Python Weather Server
cd 17-mcp-servers/02-weather-server-python
uv sync
uv run python test_weather.py
# Configure with Claude Desktop or Windsurf using README instructions
# TypeScript Weather Server
cd 17-mcp-servers/01-weather-server-typescript
npm install
npm run build
npm run test
# Configure with Claude Desktop or Windsurf using README instructions
# Auth0 MCP Server (Production)
cd 17-mcp-servers/09-remote-mcp-auth0/mcp-auth0-oidc
npm run build
npm run deploy
# Configure Claude Desktop with OAuth authentication
# Context Engineering
cd 17-mcp-servers/10-context-engineering-mcp
uv sync
fastmcp dev verbose_mcp_server.py
# Development with MCP Inspector
# Agent Skills
cd 17-mcp-servers/11-agent-skills
npm install
npm run dev
# Next.js development server
# AI Data Generator Agent
cd 18-AI-agent
uv sync
cp .env.example .env
# Edit .env with your Google AI API key
uv run main.py
# Start the AI agent
# Multi-Source Research Agent
cd 22-AI-Search-Agent
uv sync
cp .env.example .env
# Edit .env with Bright Data and Google API keys
uv run main.py
# Start the multi-source research agent
# Multi-LLM Evaluation System
cd 23-AI-Agent
uv sync
cp .env.example .env
# Edit .env with OpenAI and Google API keys
uv run main.py
# Compare responses from OpenAI, Gemini, and Ollama
# AI Career Assistant with Tool Use
cd 24-AI-Career-Assistant
uv sync
cp .env.example .env
# Edit .env with OpenAI and Pushover API keys
uv run main.py
# Launch professional career assistant with real-time notifications# Django Projects
pytest # AIHR Project
python manage.py test # Django-React Backend
# React Frontend
npm test # Frontend unit tests
npm run test:coverage # Coverage reports
# AI-Powered Meeting System
uv run python test_mcp_client.py # Test MCP server integration
curl http://localhost:8001/docs # API documentation testing
# MCP Weather Servers
cd 17-mcp-servers/02-weather-server-python
uv run python test_weather.py # Test Python MCP server
cd ../01-weather-server-typescript
npm run test # Test TypeScript MCP server
mcp-inspector node build/index.js # Interactive testing- PEP 8 Compliance: All Python code follows style guidelines
- ESLint Configuration: JavaScript/React code quality
- Type Safety: PropTypes and TypeScript considerations
- Documentation: Comprehensive inline and external documentation
- Full-Stack Proficiency: End-to-end application development
- Modern Architecture: Microservices, REST APIs, SPAs
- AI Integration: Practical LLM implementation in production
- Security-First: Authentication, authorization, data protection
- AI-Powered Solutions: Real-world AI integration beyond demos
- Scalable Design: Enterprise-ready architecture patterns
- User-Centric Approach: Responsive design, UX considerations
- Performance Optimization: Efficient database queries, frontend optimization
- Continuous Learning: Progressive skill development
- Adaptability: Multiple tech stacks and paradigms
- Best Practices: Industry-standard development workflows
- Collaboration Ready: Clean code, documentation, version control
A sophisticated AI-powered search application built with LangGraph that combines web search capabilities, push notifications, and persistent conversation memory. This project demonstrates advanced LangGraph features including state management, tool integration, conditional routing, and SQLite-based checkpointing for production-ready conversational AI systems.
- 🔍 Intelligent Web Search: Google Serper API integration for real-time web search
- 📱 Push Notifications: Pushover integration for mobile notifications
- 💾 Persistent Memory: SQLite-based conversation history and state persistence
- 🔄 Tool-Based Architecture: Modular tool system with conditional routing
- 🧠 State Management: Advanced LangGraph state handling with checkpointing
- 💬 Interactive Chat Interface: Gradio-powered real-time conversational UI
- 📊 State Visualization: Complete graph structure and state history debugging
class State(TypedDict):
messages: Annotated[list, add_messages]
@tool
def search(query: str) -> str:
"""Useful for when you need more information from an online search."""
return serper.run(query)
@tool
def send_push_notification(content: str, title: str = "Langchain Search Result") -> str:
"""Useful for when you want to send a push notification."""
return push(content, title)
# SQLite-based persistent memory
conn = sqlite3.connect("db/memory.db", check_same_thread=False)
sql_memory = SqliteSaver(conn)
graph = graph_builder.compile(checkpointer=sql_memory)- Framework: LangGraph for graph-based agent workflows with conditional routing
- AI/ML: GPT-4o with tool binding for intelligent decision making
- Search: Google Serper API for real-time web search
- Notifications: Pushover API for mobile notifications
- Database: SQLite with SqliteSaver for persistent state management
- Frontend: Gradio for web-based chat interface
- Tools: LangChain Core for tool integration and validation
Graph-Based Processing with Tool Routing:
- User Input → Gradio ChatInterface receives message
- State Creation → LangGraph State with conversation history
- LLM Processing → GPT-4o with tool binding decides tool usage
- Conditional Routing →
tools_conditionroutes to tools if needed - Tool Execution → Search or Push Notification tools process
- Response Return → Updated conversation state delivered to user
State Management with Persistence:
def chat(user_input: str, history):
result = graph.invoke(
{"messages": [{"role": "user", "content": user_input}]},
config=config
)
# Real-time state debugging
state = graph.get_state(config)
history = list(graph.get_state_history(config))
print("📊 State:", state)
print("📜 History length:", len(history))
return result["messages"][-1].content- LLM Processing: 200-800ms depending on query complexity
- Web Search: 300-1500ms depending on search complexity
- Push Notifications: 100-300ms
- Database Operations: <50ms for state retrieval
- Total Response: 600-2500ms typical
- Memory Usage: ~100MB baseline + conversation history
- Database Storage: ~1KB per conversation turn
- 🏢 Research Assistants: Automated web search with notification delivery
- 🔧 Development Tools: Code documentation search with build notifications
- 📊 Market Intelligence: Real-time information gathering with alerts
- 📚 Educational Tools: Research automation for students and educators
- 🚨 System Monitoring: Error investigation with alert notifications
State-of-the-Art Architecture:
- LangGraph's conditional routing for intelligent tool selection
- SQLite-based persistent memory with msgpack serialization
- Real-time state debugging and history visualization
- Modular tool system with automatic LLM integration
Developer Experience:
- Comprehensive state debugging with console output
- Database inspection tools for conversation analysis
- Modular tool architecture for easy expansion
- Production-ready error handling and validation
- Multi-Search Support: Multiple search engines (Bing, DuckDuckGo)
- Advanced Filtering: Search result filtering and ranking
- Conversation Analytics: Usage metrics and insights
- Webhook Integration: Custom notification endpoints
- File Upload: Document search and analysis
- Voice Interface: Speech-to-text and text-to-speech
A sophisticated web scraping assistant that combines LangGraph with Playwright to extract content from any website, including news sites with anti-bot protection like CNN and BBC.
- Anti-Bot Bypass: Uses stealth techniques to bypass modern anti-bot detection systems
- Fresh Browser Context: Creates isolated browser instances per request to avoid event loop conflicts
- Smart Navigation: Uses
domcontentloadedwait strategy to avoid waiting for heavy JavaScript and ads - Real-time Content Extraction: Extracts visible text from any website including CNN, BBC, and other protected sites
- Push Notifications Integration: Send extracted content via Pushover notifications
- Interactive Chat Interface: Natural language queries through Gradio chat UI
# Fresh browser context per request to avoid conflicts
@tool
async def get_webpage_content(url: str) -> str:
"""Fetch text content from any website including news sites"""
from playwright.async_api import async_playwright
playwright = await async_playwright().start()
browser = await playwright.chromium.launch(headless=False)
# Use domcontentloaded to avoid waiting for all resources
await page.goto(url, wait_until="domcontentloaded", timeout=30000)
await page.wait_for_timeout(3000) # Wait for JS rendering
text = await page.inner_text("body")
# Cleanup
await context.close()
await browser.close()
await playwright.stop()
return text- AI Framework: LangGraph with OpenAI GPT-4o-mini for intelligent tool selection
- Web Automation: Playwright async_api directly (bypasses LangChain toolkit limitations)
- UI: Gradio chat interface for natural language interaction
- Notifications: Pushover API for real-time alerts
- Package Management: UV for modern Python dependency management
The Problem: Traditional scraping fails on modern news sites due to:
- Anti-bot detection systems (Cloudflare, DataDome)
- Heavy JavaScript content that never finishes loading
- Resource loading timeouts when waiting for all assets
The Solution:
playwright.async_apidirectly instead of LangChain's toolkitwait_until="domcontentloaded"to wait only for HTML, not all resources- Fresh browser context per request to avoid event loop conflicts
- Realistic User-Agent to avoid basic detection
- 3-second wait after navigation for dynamic content rendering
- CNN Extraction: ~16 seconds (including browser launch)
- Simple Sites: ~5-8 seconds
- Memory Usage: ~200MB per request (cleaned up after)
- Success Rate: 95%+ on tested news sites
- Browser Strategy: Headful mode for better bypass capability
# Start the web scraping assistant
cd 34-langgraph-playwright
uv run main.py
# Available at http://127.0.0.1:7860
# Natural language queries:
User: "dame el titulo de CNN"
Bot: Extracts and displays CNN's main headline
User: "muéstrame el contenido de https://www.bbc.com/news"
Bot: Navigates and extracts all text content
User: "enviame una notificacion con el headline de CNN"
Bot: Scrapes CNN and sends push notification- ✅ News Sites: CNN, BBC, etc. (bypasses anti-bot protection)
- ✅ Wikipedia: Articles and content pages
- ✅ Blogs: Most blog platforms and CMS sites
- ✅ Practice Sites: quotes.toscrape.com, httpbin.org
- ✅ General Websites: Any HTML content on the web
- Content Monitoring: Automated news and content tracking
- Competitive Intelligence: Extract competitor information
- Research Automation: Academic and market research data collection
- Content Aggregation: Build custom news feeds and summaries
- SEO Analysis: Extract and analyze website content
┌─────────────────┐ ┌──────────────┐ ┌─────────────┐
│ Gradio UI │───▶│ LangGraph │───▶│ Playwright │
│ (Chat Interface)│ │ (Agent) │ │ (Browser) │
└─────────────────┘ └──────────────┘ └─────────────┘
│
▼
┌──────────────┐
│ Pushover │
│ Notifications│
└──────────────┘
- Isolated Contexts: Each request uses separate browser instance
- No Persistent Data: No cookies or sessions stored between requests
- Automatic Cleanup: Browser resources cleaned up after each extraction
- Rate Limiting: Built-in timeouts and error handling
- User-Agent Spoofing: Basic fingerprinting protection
An intelligent multi-agent system that combines a Worker agent with an Evaluator agent to complete tasks with quality assurance. The system uses structured outputs and continuous feedback loops to ensure success criteria are met.
- Multi-Agent Architecture: Worker agent executes tasks, Evaluator agent ensures quality
- Structured Outputs: Pydantic models for reliable agent communication
- Success Criteria Tracking: Define and validate completion criteria
- Feedback Loop: Continuous improvement through evaluator feedback
- Playwright Integration: Web scraping capabilities with anti-bot bypass
- Interactive UI: Gradio interface with success criteria input
- Persistent Memory: Thread-based conversation history
# Structured output for quality assurance
class EvaluatorOutput(BaseModel):
feedback: str
success_criteria_met: bool
user_input_needed: bool
# Multi-agent state management
class State(TypedDict):
messages: Annotated[List[Any], add_messages]
success_criteria: str
feedback_on_work: Optional[str]
success_criteria_met: bool
user_input_needed: bool- AI Framework: LangGraph with OpenAI GPT-4o-mini
- Multi-Agent System: Worker + Evaluator agents with structured outputs
- Web Automation: Playwright async_api for web scraping
- UI: Gradio 6.x with success criteria input
- Structured Data: Pydantic models for agent communication
- Package Management: UV for modern Python dependency management
START → Worker → Tools? → Evaluator → Success? → END
↑ ↓
└──────── Feedback Loop ───────┘
- Task Completion: 85-95% success rate with proper criteria
- Iteration Cycles: 1-3 feedback loops per task average
- Web Scraping: ~16 seconds for CNN with anti-bot bypass
- Memory Usage: ~250MB per conversation thread
- Response Time: 2-5 seconds per agent evaluation
# Start the Sidekick system
cd 35-langgraph-sidekick
uv run main.py
# Available at http://127.0.0.1:7860
# Example workflow:
User Request: "Get me the main headline from CNN"
Success Criteria: "Response contains the current headline text"
# Process:
# 1. Worker scrapes CNN using Playwright
# 2. Evaluator checks if headline is present
# 3. If not met, provides feedback and worker tries again
# 4. Loop continues until criteria satisfied- Quality Assurance: Automated review and validation processes
- Research Tasks: Web scraping with content validation
- Data Extraction: Structured information gathering with verification
- Content Creation: Writing with quality criteria enforcement
- Process Automation: Multi-step tasks with approval loops
┌──────────────┐
│ START │
└──────┬───────┘
│
▼
┌──────────────┐
│ Worker │◄─────┐
│ Agent │ │
└──────┬───────┘ │
│ │
▼ │
┌────────┐ │
│ Tools? │──Yes──►┌─┴────────┐
└───┬────┘ │ Playwright│
│ │ Tools │
No └───────────┘
│ │
▼ │
┌──────────────┐ │
│ Evaluator │ │
│ Agent │◄─────────┘
└──────┬───────┘
│
┌────┴─────┐
│ Success? │
└────┬─────┘
│
┌──┴──┐
│ Yes │──► END
└─────┘
│
No
│
(Loop back to Worker)
def worker(state: State) -> Dict[str, Any]:
"""
- Receives task and success criteria
- Uses tools to complete assignment
- Can ask clarifying questions
- Returns response for evaluation
"""def evaluator(state: State) -> State:
"""
- Reviews worker's response
- Checks against success criteria
- Provides structured feedback
- Decides: continue, end, or need user input
"""class EvaluatorOutput(BaseModel):
feedback: str # What needs improvement
success_criteria_met: bool # Task complete?
user_input_needed: bool # Need clarification?- Success Criteria Input: Define explicit completion requirements
- Real-time Feedback: See both worker output and evaluation
- Thread Management: Persistent conversation history
- Reset Functionality: Start fresh tasks
- Progress Visualization: Track iteration cycles
- Structured Communication: Pydantic models prevent malformed data
- Isolated Execution: Each task runs in separate context
- Input Validation: Success criteria must be specific and measurable
- Error Handling: Graceful failure with user feedback
- Resource Cleanup: Automatic cleanup of browser instances
- Multi-agent systems with specialized roles
- Structured outputs using Pydantic
- Feedback loops for iterative improvement
- State management in LangGraph
- Conditional routing based on agent decisions
- Tool integration with async operations
- Quality assurance patterns in AI systems
Category: Multi-Agent Systems | Framework: Microsoft AutoGen | Language: Python 3.14+
A sophisticated multi-agent airline assistant system demonstrating Microsoft AutoGen's capabilities with tool integration, database connectivity, and streaming responses.
- 🤖 Multi-Agent Architecture: Two specialized agents with different capabilities
- 🔧 Tool Integration: Custom database lookup tools for real-time pricing
- 💾 Database Connectivity: SQLite for persistent city pricing data
- 🌐 Multiple Model Support: OpenAI and Ollama client compatibility
- 📡 Streaming Support: Real-time response streaming with cancellation
- 🎭 Personality: Humorous airline assistant with character
# Basic Agent - Simple responses with humor
agent = AssistantAgent(
name="airline_agent",
model_client=model_client,
system_message="You are a helpful assistant for an airline. You give short, humorous answers.",
model_client_stream=True
)
# Smart Agent - Enhanced with database tools
smart_agent = AssistantAgent(
name="smart_airline_agent",
model_client=model_client,
tools=[get_city_price],
reflect_on_tool_use=True
)- Framework: Microsoft AutoGen with agent chat system
- Database: SQLite with city pricing information
- Tools: Custom Python functions for data lookup
- Models: OpenAI GPT-4o-mini and Ollama Llama 3.2 support
- Async: Full async/await with cancellation tokens
CREATE TABLE cities (
city_name TEXT PRIMARY KEY,
round_trip_price REAL
);
-- Sample pricing data
London: $299 | Paris: $399 | Rome: $499
Madrid: $550 | Barcelona: $580 | Berlin: $525uv run main.pyOutput:
id='df91f741-ef78-4ff4-9857-a3168a936477' source='user' content="I'd like to go to London"
Sure! Just be sure to pack your umbrella—it rains there more than it does in a wet sponge factory! 🇬🇧☔️
[FunctionCall(id='call_WzrArgxwhjXcox4UdLmU92el', arguments='{"city_name":"London"}', name='get_city_price')]
[FunctionExecutionResult(content='299.0', name='get_city_price')]
Sure! A roundtrip ticket to London is just $299. Pack your umbrella—it's always raining or suspending!
- Multi-Agent Systems: Understanding agent specialization and coordination
- Tool Integration: Implementing custom tools for data access
- Database Integration: SQLite with async Python operations
- Streaming Responses: Real-time agent communication
- Framework Mastery: Microsoft AutoGen best practices
dependencies = [
"autogen-ext>=0.7.5", # AutoGen extensions
"autogen-agentchat>=0.0.1", # Agent chat framework
"openai>=1.0.0", # OpenAI client
"python-dotenv>=1.2.1", # Environment variables
"tiktoken>=0.5.0", # Tokenization
"ollama>=0.1.0", # Ollama client
]- Educational Focus: Perfect for learning multi-agent concepts
- Practical Tools: Real-world database integration example
- Modern Stack: Latest Python 3.14+ with uv package manager
- Extensible: Easy to add new tools and agents
- Production Ready: Error handling and cancellation support
Project Repository: 36-autogen_agent_chat
Category: Multi-Modal AI | Framework: Microsoft AutoGen | Language: Python 3.14+
A sophisticated multi-modal AI system demonstrating advanced image analysis capabilities using Microsoft AutoGen with structured outputs and OpenAI's vision models.
- 🖼️ Multi-Modal Processing: Image + Text input handling with vision capabilities
- 📋 Structured Outputs: Pydantic model validation for type-safe responses
- 👁️ Vision Analysis: OpenAI GPT-4o-mini integration for image understanding
- 🔒 Type Safety: Strong typing with Literal types and Field validation
- 📝 Formatted Display: Clean output with text wrapping and organization
- 🔄 Flexible Output: Both structured and unstructured response modes
class ImageDescription(BaseModel):
scene: str = Field(description="Briefly, the overall scene of the image")
message: str = Field(description="The point that the image is trying to convey")
style: str = Field(description="The artistic style of the image")
orientation: Literal["portrait", "landscape", "square"] = Field(description="The orientation of the image")
# Multi-modal agent with structured output
describer = AssistantAgent(
name="description_agent",
model_client=model_client,
output_content_type=ImageDescription, # Structured validation
)- Framework: Microsoft AutoGen with multi-modal agent chat
- Vision Model: OpenAI GPT-4o-mini with image analysis
- Image Processing: PIL + AutoGen Image format conversion
- Data Validation: Pydantic models with Field descriptions
- URL Loading: Requests library for remote image fetching
- Output Formatting: textwrap for clean terminal display
# 1. Load image from URL
pil_image = Image.open(BytesIO(requests.get(url).content))
img = AGImage(pil_image)
# 2. Create multi-modal message
multi_modal_message = MultiModalMessage(
content=["Describe the content of this image in detail", img],
source="User"
)
# 3. Process with structured output
response = await describer.on_messages([multi_modal_message], cancellation_token=CancellationToken())
reply = response.chat_message.content
# 4. Access validated fields
print(f"Scene:\n{textwrap.fill(reply.scene)}")
print(f"Message:\n{textwrap.fill(reply.message)}")
print(f"Style:\n{textwrap.fill(reply.style)}")
print(f"Orientation:\n{textwrap.fill(reply.orientation)}")uv run main.pyStructured Output:
Scene:
A professional headshot of a man in a business setting, wearing a collared shirt and looking directly at the camera with a confident expression
Message:
The image conveys professionalism and expertise, representing a software engineer's transition to AI/ML roles
Style:
Professional corporate photography with clean lighting and neutral background
Orientation:
portrait
- Multi-Modal AI: Understanding vision + text processing
- Structured Outputs: Pydantic model validation and type safety
- Image Processing: PIL, AutoGen Image format conversion
- Vision APIs: OpenAI GPT-4o-mini integration
- Data Validation: Strong typing with Literal types
- Framework Mastery: Microsoft AutoGen multi-modal capabilities
dependencies = [
"autogen-ext>=0.7.5", # AutoGen extensions
"autogen-agentchat>=0.0.1", # Agent chat framework
"openai>=1.0.0", # OpenAI client with vision
"python-dotenv>=1.2.1", # Environment variables
"tiktoken>=0.5.0", # Tokenization
"pydantic>=2.0.0", # Structured data validation
"pillow>=10.0.0", # Image processing
"requests>=2.31.0", # HTTP requests
]- Vision Integration: Advanced image analysis with GPT-4o-mini
- Type Safety: Pydantic models ensure structured, validated outputs
- Multi-Modal: Seamlessly combines text and image inputs
- Educational: Perfect for learning multi-modal AI concepts
- Modern Stack: Latest Python 3.14+ with uv package manager
- Extensible: Easy to add new analysis fields and capabilities
- Production Ready: Error handling and validation included
- URL-based Image Loading: Download and process images from web
- Field Validation: Detailed Pydantic Field descriptions for AI guidance
- Literal Types: Restricted choices for orientation (portrait/landscape/square)
- Formatted Output: Clean terminal display with text wrapping
- Debug Mode: Raw response inspection and logging capabilities
Project Repository: 37-autogen_agent_chat_multi_modal
Category: Multi-Agent Integration | Frameworks: Microsoft AutoGen + LangChain | Language: Python 3.14+
A sophisticated multi-agent system demonstrating the powerful integration between Microsoft AutoGen and LangChain's extensive tool ecosystem for building intelligent workflow automation.
- 🔗 Framework Integration: Seamless AutoGen + LangChain tool integration via LangChainToolAdapter
- 🌐 Internet Search: Google Serper API integration for real-time web search capabilities
- 📁 File Management: Complete file operations (read, write, copy, delete, move, search) in sandbox environment
- 🤔 Tool Reflection: Agent reflects on tool usage for improved decision making
- 📋 Multi-Step Workflows: Complex task decomposition and sequential execution
- 📝 Report Generation: Automatic markdown report creation with structured data formatting
from autogen_ext.tools.langchain import LangChainToolAdapter
from langchain_core.tools import tool
# Modern LangChain tool with @tool decorator
@tool
def internet_search(query: str) -> str:
"""Useful for when you need to search the internet."""
return serper.run(query)
# Convert LangChain tool to AutoGen format
autogen_serper = LangChainToolAdapter(internet_search)
# Agent with tool reflection
agent = AssistantAgent(
name="searcher",
model_client=model_client,
tools=autogen_tools,
reflect_on_tool_use=True
)- Framework Integration: LangChainToolAdapter bridges LangChain tools with AutoGen agents
- Search API: Google Serper for real-time web search with flight data
- File Management: LangChain FileManagementToolkit for sandboxed file operations
- Tool Reflection: Agents analyze tool usage for better workflow optimization
- Sequential Processing: Multi-turn conversations for complex task completion
# Available Tools (8 total)
1. internet_search - Google Serper API web search
2. copy_file - Create file copies
3. file_delete - Delete files
4. file_search - Recursive regex search
5. move_file - Move/rename files
6. read_file - Read file contents
7. write_file - Write files to disk
8. list_directory - List directory contentsuv run main.pyMulti-Step Workflow Execution:
toolFileManagement internet_search Useful for when you need to search the internet.
toolFileManagement write_file Write file to disk
toolFileManagement read_file Read file from disk
...
[FunctionCall(id='call_RRKvU7Rs1DwyTxA2STYnFmob', arguments='{"query":"one-way non-stop flight deals from JFK to LHR in June 2026"}', name='internet_search')]
[FunctionExecutionResult(content="Flight deals from $205 to $461...", name='internet_search')]
[FunctionCall(id='call_IYW4ISlmwPpSumN0a3fMUbm4', arguments='{"file_path":"flights.md","text":"# Flights from JFK to LHR..."}', name='write_file')]
[FunctionExecutionResult(content='File written successfully to flights.md.', name='write_file')]
**Selected Flight:**
- **Airline:** American Airlines | **Price:** $205 | **Date:** June 1, 2026
- **Route:** JFK → LHR | **Duration:** 7 hours | **Non-stop:** Yes
- Framework Integration: Understanding AutoGen + LangChain interoperability
- Tool Adaptation: Converting LangChain tools to AutoGen-compatible format
- Workflow Orchestration: Multi-step task decomposition and execution
- API Integration: Real-time search with Google Serper API
- File Management: Sandboxed file operations for safety
- Reflection Patterns: Agent self-analysis for tool optimization
dependencies = [
"autogen-ext>=0.7.5", # AutoGen extensions
"autogen-agentchat>=0.0.1", # Agent chat framework
"openai>=1.0.0", # OpenAI client
"python-dotenv>=1.2.1", # Environment variables
"tiktoken>=0.5.0", # Tokenization
"ipython>=9.10.0", # Display utilities
"langchain-google-community>=3.0.5", # Google Serper integration
"langchain>=1.2.10", # LangChain framework
]- Powerful Integration: Demonstrates AutoGen + LangChain interoperability
- Real-Time Search: Live flight data from Google Serper API
- Tool Ecosystem: 8 different tools for comprehensive workflow automation
- Reflection Capabilities: Agents analyze and optimize tool usage
- Production Ready: Error handling, sandboxing, and structured outputs
- Educational Value: Perfect for learning multi-framework AI integration
- LangChainToolAdapter: Seamless tool format conversion between frameworks
- Modern @tool Decorator: Type-safe tool creation with Pydantic validation
- Sandbox Environment: Isolated file operations for security
- Multi-Turn Processing: Sequential message handling for complex workflows
- Structured Output: Markdown report generation with formatted data
- API Integration: Real-time web search with commercial-grade APIs
Project Repository: 38-autogen_agent_chat_with_langchain
Category: Multi-Agent Systems | Frameworks: Microsoft AutoGen | Language: Python 3.14+
An advanced multi-agent conversation system implementing Microsoft AutoGen's RoundRobinGroupChat with a professional class-based architecture, structured dialogue management, iterative feedback loops, and comprehensive error handling.
- 🏗️ Class-Based Architecture:
FlightResearchSystemclass with modular design and clean separation of concerns - 🔄 RoundRobin Conversation: Alternating turns between primary and evaluator agents with structured logging
- 📝 Iterative Feedback: Evaluator provides constructive feedback for response improvement
- ✅ Approval-Based Termination: Automatic termination when evaluator responds with "APPROVE"
- 🔍 LangChain Integration: Google Serper API for real-time internet search with error recovery
- 🎯 Structured Dialogue: Organized conversation flow with clear turn management
- 📊 Quality Assurance: Multi-round refinement ensures high-quality responses
- 🛡️ Robust Error Handling: Comprehensive exception management and environment validation
- 📋 Professional Logging: Structured logging with timestamps, severity levels, and debugging information
class FlightResearchSystem:
"""A system that manages agents to research flight deals using Serper and OpenAI."""
def __init__(self, model_name: str = "gpt-4o-mini", max_turns: int = 20):
self._validate_environment()
self.model_client = OpenAIChatCompletionClient(model=self.model_name)
self.team = self._setup_team()
def _validate_environment(self) -> None:
"""Validate required environment variables."""
required_vars = ["OPENAI_API_KEY", "SERPER_API_KEY"]
# Environment validation logic
async def run(self, task_prompt: str) -> None:
"""Execute the research task with comprehensive logging."""
result = await self.team.run(task=task_prompt)
# Structured output with logging- Prompt vs System Message: Instructions in user prompt are more effective than system message when using tools
- Iterative Improvement: Multi-turn conversations with feedback produce better results
- Termination Conditions:
TextMentionTerminationworks reliably for approval-based workflows - Tool Integration: LangChain tools can be seamlessly integrated with AutoGen agents
- Class-Based Architecture: Encapsulating functionality in classes improves code organization and reusability
- Environment Validation: Validating configuration early prevents runtime errors and improves user experience
- Structured Logging: Professional logging with different severity levels aids debugging and monitoring
- Error Handling: Comprehensive exception management makes the system more robust and user-friendly
dependencies = [
"autogen-agentchat>=0.0.1", # Agent chat framework
"autogen-ext.models.openai", # OpenAI model integration
"autogen-ext.tools.langchain", # LangChain tool adapter
"langchain-community>=3.0.5", # Google Serper integration
"langchain-core>=1.2.10", # LangChain framework
"python-dotenv>=1.2.1", # Environment variables
]- Professional Architecture: Class-based design with clean separation of concerns and reusability
- Structured Dialogue: RoundRobin pattern ensures organized conversation flow with logging
- Quality Enhancement: Multi-round feedback improves response quality with error recovery
- Real-Time Search: Live flight data integration with Google Serper API and fallback handling
- Approval Workflow: Clear termination condition with explicit approval and logging confirmation
- Debugging Insights: Comprehensive logging with timestamps, severity levels, and error tracking
- Environment Validation: Automatic configuration checking prevents runtime errors
- Educational Value: Perfect for learning multi-agent conversation patterns with best practices
- Turn Management: Automatic alternation between agents with structured logging
- Feedback Processing: Agents incorporate evaluator feedback for improvement with error handling
- Search Integration: LangChain tools for internet search capabilities with graceful error recovery
- Termination Control: Text-based approval system for conversation ending with logging
- Error Handling: Comprehensive exception management with user-friendly error messages
- Response Formatting: Structured output with professional presentation and debugging information
- Environment Validation: Startup validation ensures all required variables are configured
- Modular Design: Clean separation between agent configuration, validation, and execution logic
Project Repository: 39-autogen_agent_chat_roundrobin
All projects are open source and available under the MIT License - see individual project licenses for details.
💡 Note: This portfolio represents a journey of continuous learning and technical growth. Each project builds upon previous knowledge, demonstrating the ability to master new technologies and apply them to solve real-world problems.
🚀 Ready to bring this expertise to your team!