Real AI Agents We've Built

# Appointment Booking Agent
from langchain.agents import AgentExecutor
from langchain.tools import Tool

class AppointmentAgent:
    def __init__(self, calendar_api, sms_service):
        self.calendar = calendar_api
        self.sms = sms_service
    
    def book_appointment(self, customer_request):
        # Parse request using LLM
        details = self.parse_booking_request(customer_request)
        
        # Find available slots
        slots = self.calendar.get_available_slots(
            date=details['preferred_date'],
            duration=details['service_duration']
        )
        
        # Book and confirm
        booking = self.calendar.create_event(slots[0])
        self.sms.send_confirmation(
            customer_phone=details['phone'],
            appointment_time=booking.start_time
        )
        
        return booking

# Lead Follow-Up Agent
from openai import OpenAI
import smtplib

class LeadAgent:
    def __init__(self, crm_api, email_service):
        self.crm = crm_api
        self.email = email_service
        self.ai = OpenAI()
    
    def process_new_lead(self, lead_data):
        # Qualify lead using AI
        qualification = self.ai.chat.completions.create(
            model="gpt-4",
            messages=[{
                "role": "system",
                "content": "Qualify this lead and suggest next steps"
            }, {
                "role": "user",
                "content": f"Lead: {lead_data}"
            }]
        )
        
        # Send personalized response
        response = self.generate_response(
            lead_data,
            qualification.choices[0].message.content
        )
        
        self.email.send(
            to=lead_data['email'],
            subject="Thanks for your interest!",
            body=response
        )
        
        # Update CRM
        self.crm.create_lead(lead_data, qualification)

# Customer Support Agent
from langchain.chains import ConversationalRetrievalChain
from langchain.vectorstores import Pinecone

class SupportAgent:
    def __init__(self, knowledge_base, ticket_system):
        self.kb = knowledge_base
        self.tickets = ticket_system
        self.chain = ConversationalRetrievalChain.from_llm(
            llm=ChatOpenAI(model="gpt-4"),
            retriever=self.kb.as_retriever()
        )
    
    def handle_inquiry(self, customer_message, conversation_history):
        # Search knowledge base
        response = self.chain.run({
            "question": customer_message,
            "chat_history": conversation_history
        })
        
        # Check if escalation needed
        if self.needs_human_help(customer_message, response):
            ticket = self.tickets.create(
                customer=customer_message['from'],
                issue=customer_message['text'],
                priority="high"
            )
            return f"I've created ticket #{ticket.id} for our team"

# Data Entry Automation Agent
from langchain.document_loaders import PyPDFLoader
import pandas as pd

class DataEntryAgent:
    def __init__(self, database, email_monitor):
        self.db = database
        self.email = email_monitor
        self.extractor = DocumentIntelligence()
    
    def process_invoice(self, pdf_path):
        # Extract data from PDF
        loader = PyPDFLoader(pdf_path)
        pages = loader.load()
        
        # Use AI to extract structured data
        invoice_data = self.extractor.extract_invoice(pages)
        
        # Validate and clean data
        validated = self.validate_invoice_data(invoice_data)
        
        # Update database
        self.db.invoices.insert({
            'vendor': validated['vendor'],
            'amount': validated['total'],
            'date': validated['invoice_date'],
            'items': validated['line_items']
        })
        
        return validated