def main(): print(“Choose your AI provider:”) print(“1. OpenAI (ChatGPT)”) print(“2. Anthropic (Claude)”) choice = input(“Enter 1 or 2: “).strip()

provider = "openai" if choice == "1" else "anthropic"
bot = AIChatbot(
    provider=provider,
    system_prompt="You are a friendly and knowledgeable assistant. "
                 "Keep responses concise but thorough."
)

print(f"\nChatbot ready ({provider}). Type 'quit' to exit.")
print("Type 'switch' to change provider.")
print("Type 'reset' to clear conversation history.\n")

while True:
    user_input = input("You: ").strip()
    if not user_input:
        continue
    if user_input.lower() == "quit":
        print("Goodbye!")
        break
    if user_input.lower() == "reset":
        bot.reset()
        print("Conversation history cleared.\n")
        continue
    if user_input.lower() == "switch":
        new_provider = (
            "anthropic" if bot.provider == "openai" else "openai"
        )
        bot = AIChatbot(provider=new_provider,
                      system_prompt=bot.system_prompt)
        print(f"Switched to {new_provider}.\n")
        continue

    response = bot.send_message(user_input)
    print(f"\nBot: {response}\n")

stream = self.client.chat.completions.create(
    model=self.model,
    messages=messages,
    max_tokens=1024,
    temperature=0.7,
    stream=True
)
full_response = ""
for chunk in stream:
    if chunk.choices[0].delta.content:
        token = chunk.choices[0].delta.content
        print(token, end="", flush=True)
        full_response += token
print()  # newline after streaming completes
return full_response

def send_message_safe(self, user_message, max_retries=3): self.conversation_history.append( {“role”: “user”, “content”: user_message} )

for attempt in range(max_retries):
    try:
        if self.provider == "openai":
            response = self._call_openai()
        else:
            response = self._call_anthropic()

        self.conversation_history.append(
            {"role": "assistant", "content": response}
        )
        return response

    except (openai.RateLimitError, anthropic.RateLimitError):
        wait_time = 2 ** attempt  # exponential backoff
        print(f"Rate limited. Waiting {wait_time}s...")
        time.sleep(wait_time)

    except (openai.APIConnectionError,
            anthropic.APIConnectionError):
        print("Connection error. Retrying...")
        time.sleep(1)

    except Exception as e:
        self.conversation_history.pop()  # remove failed message
        raise e

self.conversation_history.pop()
raise Exception("Max retries exceeded")</code></pre>

The exponential backoff pattern (waiting 1s, then 2s, then 4s) is the industry-standard approach for handling rate limits. Both OpenAI and Anthropic enforce rate limits based on tokens per minute and requests per minute, and hitting them doesn't mean anything is broken — it just means you need to slow down briefly.

Step 8: Build a Simple Web Interface with Flask

A terminal chatbot is great for development, but most users expect a web interface. Here’s a minimal Flask application that serves a chat UI:

pip install flask

Create app.py:

from flask import Flask, request, jsonify, render_template_string from chatbot import AIChatbot

if name == ‘main’: app.run(debug=True, port=5000)

Run python app.py and open http://localhost:5000 in your browser. You now have a web-based AI chatbot running locally.

Step 9: Manage Conversation Memory and Token Limits

As conversations grow longer, you’ll hit token limits. GPT-4o supports up to 128K tokens of context, and Claude supports up to 200K tokens, but sending long conversations is expensive. Here’s a practical approach to managing conversation length:

def trim_history(self, max_messages=20): """Keep only the most recent messages to control costs.""" if len(self.conversation_history) > max_messages: # Always keep the most recent messages self.conversation_history = ( self.conversation_history[-max_messages:] )

def get_token_estimate(self): """Rough estimate: 1 token per 4 characters in English.""" total_chars = sum( len(m[“content”]) for m in self.conversation_history ) return total_chars // 4

For production applications, consider implementing a summarization strategy: when the conversation exceeds a threshold, use the LLM to summarize older messages into a compact context block, then replace the old messages with the summary. This preserves important context while keeping token usage under control.

A practical threshold is 50 messages or approximately 10,000 tokens. At that point, summarize the first 40 messages into a 500-token summary and keep the latest 10 messages verbatim. This approach can reduce costs by 60-80% on long conversations without noticeable quality loss.

Step 10: Deploy Your Chatbot

Once your chatbot works locally, you have several deployment options:

Option A: Deploy with Docker

FROM python:3.11-slim WORKDIR /app COPY requirements.txt . RUN pip install -r requirements.txt COPY . . EXPOSE 5000 CMD [“gunicorn”, “app:app”, “-b”, “0.0.0.0:5000”]

**Option B: Deploy to a cloud platform**

• Railway / Render: Free tier available, push-to-deploy from GitHub, ideal for prototypes.
• AWS Lambda + API Gateway: Pay-per-request pricing, good for low-traffic bots. Expect ~$0.20 per million requests plus API costs.
• Google Cloud Run: Auto-scaling containers, generous free tier (2 million requests/month).

Regardless of platform, always use environment variables for API keys in production. Never hardcode credentials.

ChatGPT API vs Claude API: Key Differences

Common Mistakes and How to Avoid Them

1. Exposing API Keys in Client-Side Code

Never put your API key in JavaScript that runs in the browser. Anyone can open DevTools and copy it. Instead, always make API calls from your backend server. Your frontend sends user messages to your server, and your server calls the AI API. This adds one network hop but protects your credentials completely.

2. Ignoring Token Costs on Long Conversations

Every message you send includes the entire conversation history. A 50-message conversation might be sending 15,000 tokens per request — and you’re paying for all of them every single time. Implement conversation trimming or summarization from day one. A user who chats for an hour could easily generate $2-5 in API costs without token management. With proper trimming, you can keep that under $0.50.

3. Using the Wrong Model for the Job

Don’t default to GPT-4o or Claude Opus for every use case. If your chatbot answers simple FAQ-style questions, GPT-3.5 Turbo or Claude Haiku will respond 3-5x faster at 10-20x lower cost. Reserve the premium models for tasks that genuinely need their reasoning capabilities — complex analysis, code generation, or nuanced writing. You can even route different types of queries to different models dynamically.

4. Not Setting a System Prompt

A chatbot without a system prompt is like an employee without a job description. The system prompt is where you define personality, boundaries, knowledge scope, and response format. Be specific: “You are a customer support agent for Acme Corp. Only answer questions about our products listed at acme.com/products. If asked about competitors, politely redirect to our products.” Vague prompts produce vague results.

5. Sending User Input Directly Without Validation

Always validate and sanitize user input before sending it to the API. Set reasonable maximum length limits (e.g., 2,000 characters per message). Check for empty messages. This prevents accidental or intentional abuse that could rack up your API bill. A single request with a 50,000-character message could cost several dollars depending on the model.

Frequently Asked Questions

How much does it cost to run an AI chatbot?

For a small-scale chatbot handling 100 conversations per day with an average of 10 messages each, expect to spend $5-15/month using GPT-4o or Claude Sonnet. Using cheaper models like GPT-3.5 Turbo or Claude Haiku, that drops to $0.50-2/month. The main cost driver is conversation length, not the number of users. A single long conversation with 100 back-and-forth messages costs more than 50 short conversations with 2 messages each.

Can I use both ChatGPT and Claude in the same application?

Absolutely — that’s exactly what this guide teaches. Many production applications use multiple models strategically. For example, you might use Claude for tasks requiring long context or careful instruction following, and GPT-4o for tasks where the OpenAI ecosystem (function calling, vision, DALL-E) adds value. The unified chatbot class in Step 4 makes switching between providers a one-line change.

Do I need a GPU or special hardware?

No. When using APIs, all the heavy computation happens on OpenAI’s or Anthropic’s servers. Your application just sends HTTP requests and receives text responses. A $5/month VPS with 512MB of RAM can comfortably run an API-based chatbot serving hundreds of concurrent users. You only need GPUs if you’re running open-source models locally (like Llama or Mistral), which is a completely different approach.

How do I make my chatbot remember information across sessions?

The APIs themselves are stateless — they don’t remember previous conversations. To add memory across sessions, store conversation histories in a database (PostgreSQL, SQLite, or even a JSON file for prototypes). When a returning user sends a message, load their previous conversation history and include it in the API request. For longer-term memory, extract key facts from conversations and store them as a user profile that gets injected into the system prompt.

Is it safe to build a customer-facing chatbot with these APIs?

Yes, with proper guardrails. Both OpenAI and Anthropic have built-in content filters, but you should add your own layer of protection. Use the system prompt to define strict boundaries for what the bot should and shouldn’t discuss. Implement input validation to reject obviously abusive messages. Log all conversations for review. And critically, never give the chatbot access to actions it shouldn’t take (like database modifications or payment processing) without human approval in the loop.

Summary and Next Steps

Here’s what you’ve accomplished in this guide:

• Set up API access for both OpenAI and Anthropic
• Made standalone API calls to each provider
• Built a unified chatbot class that abstracts away provider differences
• Added a terminal chat interface with provider switching
• Implemented streaming responses for real-time output
• Added production-ready error handling with exponential backoff
• Created a web interface using Flask
• Learned conversation memory management and cost optimization
• Explored deployment options for making your chatbot publicly accessible

Where to go from here:

• Add function calling / tool use — Let your chatbot perform actions like searching databases, calling external APIs, or processing files. Both OpenAI and Anthropic support this feature.
• Implement RAG (Retrieval-Augmented Generation) — Connect your chatbot to a knowledge base so it can answer questions about your specific documents, products, or data.
• Build a Slack or Discord bot — Integrate your chatbot into team communication tools using their respective APIs and webhooks.
• Add voice input/output — Use the OpenAI Whisper API for speech-to-text and a TTS API for text-to-speech to create a voice-enabled chatbot.
• Fine-tune for your use case — Once you have enough conversation data, fine-tune a model to match your specific domain and tone without needing lengthy system prompts.