How to Create an Intelligent Chatbot for Your SME Without Knowing AI Programming?

# Complete chatbot system for SME using multiple LLM APIs
import openai
import anthropic
import requests
import json
import time
from datetime import datetime
from typing import Dict, List, Optional
import os
from dataclasses import dataclass

@dataclass
class CompanyConfiguration:
    """Company-specific configuration"""
    company_name: str
    sector: str
    business_hours: str
    phone: str
    email: str
    products_services: List[str]
    policies: Dict[str, str]
    
class LLMAPIManager:
    """
    Unified manager for multiple LLM APIs
    """
    
    def __init__(self):
        # Configure API clients
        self.openai_client = openai.OpenAI(
            api_key=os.getenv('OPENAI_API_KEY')
        )
        
        self.anthropic_client = anthropic.Anthropic(
            api_key=os.getenv('ANTHROPIC_API_KEY')
        )
        
        # Provider configuration
        self.providers = {
            'openai': {
                'model': 'gpt-4o-mini',
                'cost_per_token': 0.000004,  # €0.004 per 1K tokens
                'token_limit': 4000
            },
            'anthropic': {
                'model': 'claude-3-haiku-20240307',
                'cost_per_token': 0.0000015,  # €0.0015 per 1K tokens
                'token_limit': 4000
            },
            'google': {
                'model': 'gemini-pro',
                'cost_per_token': 0.000001,  # €0.001 per 1K tokens
                'token_limit': 8000
            }
        }
        
        # Usage statistics
        self.statistics = {
            'total_queries': 0,
            'total_cost': 0.0,
            'average_response_time': 0.0,
            'average_satisfaction': 0.0,
            'by_provider': {}
        }
    
    def select_optimal_provider(self, query_length: int, query_type: str) -> str:
        """
        Select the most economical provider for the query type
        """
        # Selection logic based on cost and capabilities
        if query_length > 2000:  # Long queries
            return 'anthropic'  # Claude handles long texts better
        elif query_type == 'creative':  # Creative tasks
            return 'openai'  # GPT-4 better for creativity
        else:  # Standard queries
            return 'google'  # Gemini more economical for general use
    
    def generate_openai_response(self, prompt: str, company_config: CompanyConfiguration) -> Dict:
        """
        Generate response using OpenAI GPT
        """
        start_time = time.time()
        
        try:
            # Create contextualized prompt
            system_prompt = f"""
You are a customer service assistant for {company_config.company_name}, 
a company in the {company_config.sector} sector.

Company information:
- Business hours: {company_config.business_hours}
- Phone: {company_config.phone}
- Email: {company_config.email}
- Products/services: {', '.join(company_config.products_services)}

Instructions:
1. Respond in a friendly and professional manner
2. If you don't know something specific, offer to contact a human
3. Keep responses concise but useful
4. Always include a follow-up question when appropriate
"""
            
            response = self.openai_client.chat.completions.create(
                model=self.providers['openai']['model'],
                messages=[
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": prompt}
                ],
                max_tokens=self.providers['openai']['token_limit'],
                temperature=0.7
            )
            
            # Calculate cost
            tokens_used = response.usage.total_tokens
            cost = tokens_used * self.providers['openai']['cost_per_token']
            response_time = time.time() - start_time
            
            return {
                'response': response.choices[0].message.content,
                'provider': 'openai',
                'tokens_used': tokens_used,
                'cost': cost,
                'response_time': response_time,
                'success': True
            }
            
        except Exception as e:
            return {
                'response': 'Sorry, I have technical problems. Could you contact our human team?',
                'provider': 'openai',
                'error': str(e),
                'success': False
            }
    
    def generate_anthropic_response(self, prompt: str, company_config: CompanyConfiguration) -> Dict:
        """
        Generate response using Anthropic Claude
        """
        start_time = time.time()
        
        try:
            # Prompt for Claude
            complete_prompt = f"""
Human: You are a customer service assistant for {company_config.company_name}.

Company context:
- Sector: {company_config.sector}
- Hours: {company_config.business_hours}
- Contact: {company_config.phone} / {company_config.email}
- We offer: {', '.join(company_config.products_services)}

Customer query: {prompt}

Please respond in a helpful and professional manner.

Assistant: """
            
            response = self.anthropic_client.messages.create(
                model=self.providers['anthropic']['model'],
                max_tokens=self.providers['anthropic']['token_limit'],
                messages=[{"role": "user", "content": complete_prompt}]
            )
            
            # Estimate tokens (Claude doesn't always report them)
            estimated_tokens = len(complete_prompt.split()) + len(response.content[0].text.split())
            cost = estimated_tokens * self.providers['anthropic']['cost_per_token']
            response_time = time.time() - start_time
            
            return {
                'response': response.content[0].text,
                'provider': 'anthropic',
                'tokens_used': estimated_tokens,
                'cost': cost,
                'response_time': response_time,
                'success': True
            }
            
        except Exception as e:
            return {
                'response': 'Sorry, I\'m experiencing difficulties. I recommend contacting our team directly.',
                'provider': 'anthropic',
                'error': str(e),
                'success': False
            }
    
    def generate_google_response(self, prompt: str, company_config: CompanyConfiguration) -> Dict:
        """
        Generate response using Google Gemini (simulated)
        """
        start_time = time.time()
        
        # Simulation of Gemini response
        # In real implementation, use Google AI API
        
        try:
            # Here would go the real Gemini API call
            # For now, we simulate a response
            
            simulated_response = f"""Hello, I'm the virtual assistant of {company_config.company_name}. 
I understand your query about '{prompt[:50]}...'. 
Our business hours are {company_config.business_hours}. 
How else can I help you specifically?"""
            
            estimated_tokens = len(prompt.split()) + len(simulated_response.split())
            cost = estimated_tokens * self.providers['google']['cost_per_token']
            response_time = time.time() - start_time
            
            return {
                'response': simulated_response,
                'provider': 'google',
                'tokens_used': estimated_tokens,
                'cost': cost,
                'response_time': response_time,
                'success': True
            }
            
        except Exception as e:
            return {
                'response': 'Sorry, there is a technical problem. Please try again or contact our human team.',
                'provider': 'google',
                'error': str(e),
                'success': False
            }
    
    def process_query(self, query: str, company_config: CompanyConfiguration, preferred_provider: str = None) -> Dict:
        """
        Process a query using the optimal provider
        """
        # Select provider if not specified
        if not preferred_provider:
            preferred_provider = self.select_optimal_provider(
                len(query), 
                'general'  # Basic classification
            )
        
        # Generate response according to provider
        if preferred_provider == 'openai':
            result = self.generate_openai_response(query, company_config)
        elif preferred_provider == 'anthropic':
            result = self.generate_anthropic_response(query, company_config)
        elif preferred_provider == 'google':
            result = self.generate_google_response(query, company_config)
        else:
            result = self.generate_openai_response(query, company_config)  # Fallback
        
        # Update statistics
        self.update_statistics(result)
        
        return result
    
    def update_statistics(self, result: Dict):
        """
        Update usage and cost statistics
        """
        if result['success']:
            self.statistics['total_queries'] += 1
            self.statistics['total_cost'] += result['cost']
            
            # Update average time
            n = self.statistics['total_queries']
            current_time = self.statistics['average_response_time']
            new_time = result['response_time']
            self.statistics['average_response_time'] = (
                (current_time * (n - 1) + new_time) / n
            )
            
            # Statistics by provider
            provider = result['provider']
            if provider not in self.statistics['by_provider']:
                self.statistics['by_provider'][provider] = {
                    'queries': 0,
                    'total_cost': 0.0,
                    'total_tokens': 0
                }
            
            self.statistics['by_provider'][provider]['queries'] += 1
            self.statistics['by_provider'][provider]['total_cost'] += result['cost']
            self.statistics['by_provider'][provider]['total_tokens'] += result['tokens_used']
    
    def get_cost_report(self) -> Dict:
        """
        Generate detailed cost report
        """
        if self.statistics['total_queries'] == 0:
            return {"message": "No usage data available"}
        
        return {
            'summary': {
                'total_queries': self.statistics['total_queries'],
                'total_cost': round(self.statistics['total_cost'], 4),
                'average_cost_per_query': round(
                    self.statistics['total_cost'] / self.statistics['total_queries'], 4
                ),
                'average_response_time': round(
                    self.statistics['average_response_time'], 2
                )
            },
            'by_provider': self.statistics['by_provider'],
            'monthly_projection': {
                'estimated_queries': self.statistics['total_queries'] * 30,
                'estimated_cost': round(self.statistics['total_cost'] * 30, 2)
            }
        }

class SMEChatbot:
    """
    Main chatbot class for SME
    """
    
    def __init__(self, company_config: CompanyConfiguration):
        self.company_config = company_config
        self.llm_manager = LLMAPIManager()
        self.conversation_history = []
        
    def process_message(self, message: str, user_id: str = None) -> Dict:
        """
        Process a user message
        """
        # Detect query type to optimize provider
        query_type = self._classify_query(message)
        
        # Generate response
        result = self.llm_manager.process_query(
            message,
            self.company_config,
            preferred_provider=None  # Automatic selection
        )
        
        # Save to history
        self.conversation_history.append({
            'timestamp': datetime.now().isoformat(),
            'user_id': user_id,
            'message': message,
            'response': result['response'],
            'provider': result['provider'],
            'cost': result.get('cost', 0),
            'success': result['success']
        })
        
        return result
    
    def _classify_query(self, message: str) -> str:
        """
        Classify query type to optimize API selection
        """
        message_lower = message.lower()
        
        # Keywords for different types
        if any(word in message_lower for word in ['hours', 'open', 'closed', 'when']):
            return 'basic_information'
        elif any(word in message_lower for word in ['price', 'cost', 'how much', 'rate']):
            return 'pricing'
        elif any(word in message_lower for word in ['product', 'service', 'offer', 'sell']):
            return 'products'
        elif any(word in message_lower for word in ['return', 'warranty', 'exchange', 'problem']):
            return 'support'
        else:
            return 'general'
    
    def get_statistics(self) -> Dict:
        """
        Get complete chatbot statistics
        """
        total_conversations = len(self.conversation_history)
        successful_conversations = sum(1 for conv in self.conversation_history if conv['success'])
        
        stats = {
            'total_conversations': total_conversations,
            'success_rate': (successful_conversations / total_conversations * 100) if total_conversations > 0 else 0,
            'costs': self.llm_manager.get_cost_report(),
            'last_activity': self.conversation_history[-1]['timestamp'] if self.conversation_history else None
        }
        
        return stats

# Usage example
if __name__ == "__main__":
    # Configure company
    my_company = CompanyConfiguration(
        company_name="Carmen's Organic Store",
        sector="Organic food",
        business_hours="Monday to Friday 9:00-18:00",
        phone="+34 91 123 4567",
        email="info@carmensorganic.es",
        products_services=[
            "Organic fruits and vegetables",
            "Gluten-free products",
            "Natural supplements",
            "Ecological cleaning products"
        ],
        policies={
            "return": "14 days for returns",
            "shipping": "Free shipping orders >50€",
            "guarantee": "100% freshness guarantee"
        }
    )
    
    # Create chatbot
    chatbot = SMEChatbot(my_company)
    
    # Simulate conversations
    example_queries = [
        "What are your hours?",
        "Do you sell gluten-free products?",
        "How much does shipping cost?",
        "I have a problem with my order",
        "Do you have fresh organic fruits?"
    ]
    
    print("=== SME CHATBOT SIMULATION ===")
    
    for i, query in enumerate(example_queries):
        print(f"\nUser {i+1}: {query}")
        
        result = chatbot.process_message(query, f"user_{i+1}")
        
        if result['success']:
            print(f"Chatbot: {result['response']}")
            print(f"(Processed by {result['provider']}, cost: €{result['cost']:.4f})")
        else:
            print(f"Error: {result.get('error', 'Unknown error')}")
    
    # Show final statistics
    print("\n=== FINAL STATISTICS ===")
    stats = chatbot.get_statistics()
    print(f"Total conversations: {stats['total_conversations']}")
    print(f"Success rate: {stats['success_rate']:.1f}%")
    print(f"Total cost: €{stats['costs']['summary']['total_cost']:.4f}")
    print(f"Average cost per query: €{stats['costs']['summary']['average_cost_per_query']:.4f}")
    print(f"Monthly projection: €{stats['costs']['monthly_projection']['estimated_cost']:.2f}")

# ROI Calculator: Chatbot vs Human Staff
import pandas as pd
import numpy as np

class ChatbotROICalculator:
    """
    Calculate ROI of implementing chatbot vs maintaining only human staff
    """
    
    def __init__(self):
        self.scenarios = []
        
    def calculate_human_staff_costs(self, config):
        """
        Calculate customer service costs with only human staff
        """
        # Input parameters
        monthly_queries = config['monthly_queries']
        queries_per_agent_hour = config.get('queries_per_agent_hour', 8)
        monthly_work_hours = config.get('monthly_work_hours', 160)  # 40h/week
        monthly_agent_salary = config.get('monthly_agent_salary', 1800)
        social_benefits_pct = config.get('social_benefits_pct', 30)  # 30% of salary
        
        # Calculate required agents
        agent_monthly_queries = queries_per_agent_hour * monthly_work_hours
        required_agents = np.ceil(monthly_queries / agent_monthly_queries)
        
        # Monthly costs
        salary_cost = required_agents * monthly_agent_salary
        benefits_cost = salary_cost * (social_benefits_pct / 100)
        infrastructure_cost = required_agents * 200  # €200/agent/month (space, equipment)
        training_cost = required_agents * 100  # €100/agent/month (continuous training)
        
        total_monthly_cost = salary_cost + benefits_cost + infrastructure_cost + training_cost
        cost_per_query = total_monthly_cost / monthly_queries if monthly_queries > 0 else 0
        
        return {
            'required_agents': int(required_agents),
            'salary_cost': salary_cost,
            'benefits_cost': benefits_cost,
            'infrastructure_cost': infrastructure_cost,
            'training_cost': training_cost,
            'total_monthly_cost': total_monthly_cost,
            'cost_per_query': cost_per_query
        }
    
    def calculate_chatbot_costs(self, config):
        """
        Calculate chatbot costs with human backup
        """
        monthly_queries = config['monthly_queries']
        chatbot_resolution_rate = config.get('chatbot_resolution_rate', 70) / 100
        api_cost_per_query = config.get('api_cost_per_query', 0.02)  # €0.02 per query
        monthly_platform_cost = config.get('monthly_platform_cost', 100)
        initial_development_cost = config.get('initial_development_cost', 3000)
        amortization_months = config.get('amortization_months', 24)
        
        # Queries handled by chatbot vs humans
        chatbot_queries = monthly_queries * chatbot_resolution_rate
        human_queries = monthly_queries * (1 - chatbot_resolution_rate)
        
        # Chatbot costs
        monthly_api_cost = chatbot_queries * api_cost_per_query
        amortized_development_cost = initial_development_cost / amortization_months
        maintenance_cost = monthly_platform_cost * 0.2  # 20% for maintenance
        
        # Reduced human staff costs
        reduced_human_config = config.copy()
        reduced_human_config['monthly_queries'] = human_queries
        reduced_human_costs = self.calculate_human_staff_costs(reduced_human_config)
        
        # Total hybrid chatbot
        total_monthly_cost = (
            monthly_api_cost + 
            monthly_platform_cost + 
            amortized_development_cost + 
            maintenance_cost +
            reduced_human_costs['total_monthly_cost']
        )
        
        cost_per_query = total_monthly_cost / monthly_queries if monthly_queries > 0 else 0
        
        return {
            'chatbot_queries': chatbot_queries,
            'human_queries': human_queries,
            'monthly_api_cost': monthly_api_cost,
            'monthly_platform_cost': monthly_platform_cost,
            'amortized_development_cost': amortized_development_cost,
            'maintenance_cost': maintenance_cost,
            'reduced_staff_cost': reduced_human_costs['total_monthly_cost'],
            'required_human_agents': reduced_human_costs['required_agents'],
            'total_monthly_cost': total_monthly_cost,
            'cost_per_query': cost_per_query
        }
    
    def compare_scenarios(self, config):
        """
        Compare costs between humans only vs hybrid chatbot
        """
        human_costs = self.calculate_human_staff_costs(config)
        chatbot_costs = self.calculate_chatbot_costs(config)
        
        # Calculate savings
        monthly_savings = human_costs['total_monthly_cost'] - chatbot_costs['total_monthly_cost']
        annual_savings = monthly_savings * 12
        savings_percentage = (monthly_savings / human_costs['total_monthly_cost']) * 100
        
        # ROI
        initial_investment = config.get('initial_development_cost', 3000)
        months_to_recover = initial_investment / monthly_savings if monthly_savings > 0 else float('inf')
        annual_roi = ((annual_savings - initial_investment) / initial_investment) * 100 if initial_investment > 0 else 0
        
        return {
            'humans_only': human_costs,
            'hybrid_chatbot': chatbot_costs,
            'monthly_savings': monthly_savings,
            'annual_savings': annual_savings,
            'savings_percentage': savings_percentage,
            'months_to_recover': months_to_recover,
            'annual_roi': annual_roi
        }
    
    def generate_comprehensive_report(self, multiple_configs):
        """
        Generate report for multiple configurations
        """
        results = []
        
        for name, config in multiple_configs.items():
            comparison = self.compare_scenarios(config)
            result = {
                'scenario': name,
                'monthly_queries': config['monthly_queries'],
                'humans_only_cost': comparison['humans_only']['total_monthly_cost'],
                'hybrid_chatbot_cost': comparison['hybrid_chatbot']['total_monthly_cost'],
                'monthly_savings': comparison['monthly_savings'],
                'savings_percentage': comparison['savings_percentage'],
                'months_to_recover': comparison['months_to_recover'],
                'annual_roi': comparison['annual_roi']
            }
            results.append(result)
        
        return pd.DataFrame(results)
    
    def find_break_even_point(self, base_config):
        """
        Find minimum volume where chatbot is profitable
        """
        volumes = range(100, 10000, 100)  # From 100 to 10k monthly queries
        break_even_points = []
        
        for volume in volumes:
            config = base_config.copy()
            config['monthly_queries'] = volume
            
            comparison = self.compare_scenarios(config)
            
            break_even_points.append({
                'volume': volume,
                'monthly_savings': comparison['monthly_savings'],
                'profitable': comparison['monthly_savings'] > 0
            })
        
        # Find first point where it's profitable
        first_profitable = next((p for p in break_even_points if p['profitable']), None)
        
        return first_profitable['volume'] if first_profitable else None

# Use the calculator
if __name__ == "__main__":
    calculator = ChatbotROICalculator()
    
    # Configurations for different types of SME
    configurations = {
        'Small SME (e-commerce)': {
            'monthly_queries': 500,
            'queries_per_agent_hour': 10,
            'monthly_agent_salary': 1600,
            'chatbot_resolution_rate': 75,
            'initial_development_cost': 2500
        },
        'Medium SME (services)': {
            'monthly_queries': 2000,
            'queries_per_agent_hour': 8,
            'monthly_agent_salary': 1800,
            'chatbot_resolution_rate': 70,
            'initial_development_cost': 5000
        },
        'Large SME (retail)': {
            'monthly_queries': 5000,
            'queries_per_agent_hour': 12,
            'monthly_agent_salary': 2000,
            'chatbot_resolution_rate': 80,
            'initial_development_cost': 8000
        }
    }
    
    # Generate comparative report
    report = calculator.generate_comprehensive_report(configurations)
    
    print("=== CHATBOT vs HUMAN STAFF ROI ANALYSIS ===")
    print(report.round(2).to_string(index=False))
    
    # Find break-even point
    base_config = {
        'queries_per_agent_hour': 8,
        'monthly_agent_salary': 1700,
        'chatbot_resolution_rate': 70,
        'initial_development_cost': 3000
    }
    
    break_even_point = calculator.find_break_even_point(base_config)
    print(f"\n=== BREAK-EVEN POINT ===")
    print(f"Minimum volume for profitability: {break_even_point} queries/month")
    
    # Detailed analysis for medium SME
    print(f"\n=== DETAILED ANALYSIS: MEDIUM SME ===")
    detailed_comparison = calculator.compare_scenarios(configurations['Medium SME (services)'])
    
    print(f"Humans only:")
    print(f"  • Required agents: {detailed_comparison['humans_only']['required_agents']}")
    print(f"  • Monthly cost: €{detailed_comparison['humans_only']['total_monthly_cost']:,.2f}")
    
    print(f"\nHybrid chatbot:")
    print(f"  • Queries by chatbot: {detailed_comparison['hybrid_chatbot']['chatbot_queries']:.0f}")
    print(f"  • Queries by humans: {detailed_comparison['hybrid_chatbot']['human_queries']:.0f}")
    print(f"  • Required human agents: {detailed_comparison['hybrid_chatbot']['required_human_agents']}")
    print(f"  • Monthly cost: €{detailed_comparison['hybrid_chatbot']['total_monthly_cost']:,.2f}")
    
    print(f"\nBenefits:")
    print(f"  • Monthly savings: €{detailed_comparison['monthly_savings']:,.2f}")
    print(f"  • Annual savings: €{detailed_comparison['annual_savings']:,.2f}")
    print(f"  • Savings percentage: {detailed_comparison['savings_percentage']:.1f}%")
    print(f"  • Annual ROI: {detailed_comparison['annual_roi']:.1f}%")
    print(f"  • Investment recovery: {detailed_comparison['months_to_recover']:.1f} months")