import openai
from datetime import datetime
import jsonclass CustomerSupportAgent:
def __init__(self, api_key, company_info):
self.client = openai.OpenAI(api_key=api_key)
self.company_info = company_info
self.conversation_history = []
self.system_prompt = f"""
You are a helpful customer support agent for {company_info['name']}.
Company Info:
- Product: {company_info['product']}
- Key Features: {', '.join(company_info['features'])}
- Support Hours: {company_info['support_hours']}
Rules:
1. Be helpful and professional
2. Use company information to answer questions
3. Escalate complex technical issues
4. Keep responses concise but complete
"""

def add_to_memory(self, role, content):
"""Store conversation in memory"""
self.conversation_history.append({
"role": role,
"content": content,
"timestamp": datetime.now().isoformat()
})
# Keep only last 20 messages to manage context length
if len(self.conversation_history) > 20:
self.conversation_history = self.conversation_history[-20:]
def get_context(self):
"""Build context for the AI model"""
messages = [{"role": "system", "content": self.system_prompt}]
# Add conversation history
for msg in self.conversation_history:
messages.append({
"role": msg["role"],
"content": msg["content"]
})
return messages

def respond(self, user_input):
"""Generate response to user input"""
try:
# Add user input to memory
self.add_to_memory("user", user_input)
# Get response from AI
response = self.client.chat.completions.create(
model=gpt-4 ,
messages=self.get_context(),
max_tokens=500,
temperature=0.7
)
agent_response = response.choices[0].message.content
# Add response to memory
self.add_to_memory("assistant", agent_response)
return {
"response": agent_response,
"needs_escalation": self.check_escalation(user_input),
"confidence": 0.8  # Could be calculated based on response
}
except Exception as e:
return {
"response": "I apologize, but I'm experiencing technical difficulties. Please try again or contact our support team.",
"needs_escalation": True,
"error": str(e)
}
def check_escalation(self, user_input):
"""Simple escalation logic"""
escalation_keywords = ["refund", "cancel", "lawsuit", "angry", "frustrated"]
return any(keyword in user_input.lower() for keyword in escalation_keywords)

# Initialize your agent
company_info = {
"name": "TechCorp",
"product": "CloudSync Pro",
"features": ["Real-time sync", "Advanced security", "Team collaboration"],
"support_hours": "9 AM - 6 PM EST"
}agent = CustomerSupportAgent("your-api-key", company_info)# Test the agent
test_queries = [
"What features does your product have?",
"How do I sync my files?",
"I want a refund, this product is terrible!"
]for query in test_queries:
print(f"User: {query}")
result = agent.respond(query)
print(f"Agent: {result['response']}")
print(f"Escalation needed: {result['needs_escalation']}")
print("-" * 50)

class EnhancedMemory:
def __init__(self):
self.short_term = []  # Current conversation
self.long_term = {}   # Customer profile
self.semantic_memory = {}  # Learned patterns
def store_customer_info(self, info):
"""Store important customer information"""
customer_id = info.get("customer_id", "anonymous")
if customer_id not in self.long_term:
self.long_term[customer_id] = {
"interactions": 0,
"preferences": {},
"issues": [],
"satisfaction": "unknown"
}
self.long_term[customer_id].update(info)
self.long_term[customer_id]["interactions"] += 1
def recall_customer(self, customer_id):
"""Retrieve customer history"""
return self.long_term.get(customer_id, {})
def extract_intent(self, message):
"""Simple intent extraction"""
intents = {
"question": ["what", "how", "when", "where", "why"],
"problem": ["error", "bug", "issue", "problem", "broken"],
"request": ["can you", "please", "need", "want"],
"complaint": ["angry", "frustrated", "disappointed", "terrible"]
}
message_lower = message.lower()
for intent, keywords in intents.items():
if any(keyword in message_lower for keyword in keywords):
return intent
return "general"

class GoalSystem:
def __init__(self):
self.primary_goals = [
"resolve_customer_issue",
"maintain_satisfaction",
"gather_feedback"
]
self.current_goal = None
self.goal_progress = {}
def set_goal_from_intent(self, intent, context):
"""Set appropriate goal based on customer intent"""
goal_mapping = {
"problem": "resolve_customer_issue",
"question": "provide_information",
"complaint": "de_escalate_and_resolve",
"request": "fulfill_request"
}
self.current_goal = goal_mapping.get(intent, "general_assistance")
self.goal_progress[self.current_goal] = {"status": "started", "steps_completed": []}
def plan_actions(self, goal, context):
"""Plan actions to achieve goal"""
action_plans = {
"resolve_customer_issue": [
"understand_problem",
"gather_details",
"provide_solution",
"confirm_resolution"
],
"provide_information": [
"identify_information_need",
"retrieve_relevant_info",
"present_clearly"
]
}
return action_plans.get(goal, ["provide_general_help"])

Deployment: Making Your Agent Live

Your agent is built and tested—now let's deploy it. We'll create a simple web interface and prepare for production use.

Simple Web Interface

from flask import Flask, request, jsonify, render_template_stringapp = Flask(__name__)
agent = CustomerSupportAgent(api_key, company_info)@app.route('/')
def home():
return render_template_string('''
Customer Support Chat
Send
''')@app.route('/chat', methods=['POST'])
def chat():
user_message = request.json['message']
result = agent.respond(user_message)
return jsonify(result)if __name__ ==__main__ :
app.run(debug=True)

Next Steps: Enhancing Your Agent

Congratulations! You've built your first AI agent. Here's how to make it even better: