Wonderful raises $150M Series B to scale its enterprise AI agents across 30 countries

Introduction

In this tutorial, you'll learn how to build and deploy a simple enterprise AI agent using Python and popular AI frameworks. This tutorial mirrors the kind of technology that companies like Wonderful are using to scale AI solutions across global enterprises. You'll create a basic AI assistant that can understand user queries and respond with relevant information, similar to what enterprise AI agents do in production environments.

By the end of this tutorial, you'll have a working AI agent that demonstrates core concepts like natural language understanding, response generation, and system deployment - all essential components for enterprise AI solutions.

Prerequisites

To follow this tutorial, you'll need:

• A computer with internet access
• Python 3.8 or higher installed
• Basic understanding of Python programming concepts
• Some familiarity with command-line interfaces

Step-by-Step Instructions

1. Set up your development environment

First, we need to create a project directory and set up a virtual environment to keep our dependencies isolated. This is a best practice for Python development.

mkdir ai-agent-project
 cd ai-agent-project
python -m venv ai-agent-env
source ai-agent-env/bin/activate  # On Windows: ai-agent-env\Scripts\activate

Why we do this: Creating a virtual environment ensures that our project's dependencies don't conflict with other Python projects on your system.

2. Install required packages

Next, we'll install the necessary Python packages for our AI agent. We'll use OpenAI's Python library for language processing and Flask for creating a simple web interface.

pip install openai flask python-dotenv

Why we do this: OpenAI provides powerful language models, Flask helps us create a web interface, and python-dotenv allows us to manage API keys securely.

3. Get your OpenAI API key

Visit https://platform.openai.com/api-keys to get your API key. Create a new file called .env in your project directory and add your key:

OPENAI_API_KEY=your_actual_api_key_here

Why we do this: The API key authenticates your requests to OpenAI's services. Never commit this key to version control.

4. Create the AI agent core

Create a file called ai_agent.py and add the following code:

import openai
import os
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Initialize OpenAI client
openai.api_key = os.getenv('OPENAI_API_KEY')

class EnterpriseAIAgent:
    def __init__(self):
        self.system_prompt = "You are a helpful enterprise assistant. Answer questions professionally and concisely."

    def get_response(self, user_message):
        try:
            response = openai.ChatCompletion.create(
                model="gpt-3.5-turbo",
                messages=[
                    {"role": "system", "content": self.system_prompt},
                    {"role": "user", "content": user_message}
                ]
            )
            return response.choices[0].message.content
        except Exception as e:
            return f"Error processing your request: {str(e)}"

# Example usage
if __name__ == "__main__":
    agent = EnterpriseAIAgent()
    print("AI Agent ready. Type 'quit' to exit.")
    while True:
        user_input = input("You: ")
        if user_input.lower() == 'quit':
            break
        response = agent.get_response(user_input)
        print(f"Agent: {response}")

Why we do this: This creates the core functionality of our AI agent. It uses OpenAI's GPT model to understand and respond to user queries, which is fundamental to enterprise AI agents.

5. Create a web interface

Create a file called app.py to make our AI agent accessible through a web browser:

from flask import Flask, render_template, request, jsonify
from ai_agent import EnterpriseAIAgent

app = Flask(__name__)
agent = EnterpriseAIAgent()

@app.route('/')
def home():
    return render_template('index.html')

@app.route('/chat', methods=['POST'])
def chat():
    user_message = request.json['message']
    response = agent.get_response(user_message)
    return jsonify({'response': response})

if __name__ == '__main__':
    app.run(debug=True)

Why we do this: This creates a web interface that allows users to interact with our AI agent through a browser, similar to how enterprise AI agents are often deployed for user access.

6. Create HTML template

Create a folder called templates in your project directory, then create index.html inside it:

<!DOCTYPE html>
<html>
<head>
    <title>Enterprise AI Agent</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        #chat-container { max-width: 600px; margin: 0 auto; }
        #messages { height: 400px; overflow-y: scroll; border: 1px solid #ccc; padding: 10px; margin-bottom: 10px; }
        #input-area { display: flex; }
        #user-input { flex: 1; padding: 10px; }
        #send-button { padding: 10px 20px; }
    </style>
</head>
<body>
    <div id="chat-container">
        <h1>Enterprise AI Agent</h1>
        <div id="messages"></div>
        <div id="input-area">
            <input type="text" id="user-input" placeholder="Ask something...">
            <button id="send-button" onclick="sendMessage()">Send</button>
        </div>
    </div>

    <script>
        function sendMessage() {
            const input = document.getElementById('user-input');
            const message = input.value;
            if (!message) return;

            // Display user message
            addMessage('You', message);
            input.value = '';

            // Send to backend
            fetch('/chat', {
                method: 'POST',
                headers: {'Content-Type': 'application/json'},
                body: JSON.stringify({message: message})
            })
            .then(response => response.json())
            .then(data => {
                addMessage('Agent', data.response);
            });
        }

        function addMessage(sender, text) {
            const messagesDiv = document.getElementById('messages');
            const messageDiv = document.createElement('div');
            messageDiv.innerHTML = `<strong>${sender}:</strong> ${text}`;
            messagesDiv.appendChild(messageDiv);
            messagesDiv.scrollTop = messagesDiv.scrollHeight;
        }

        // Allow Enter key to send message
        document.getElementById('user-input').addEventListener('keypress', function(e) {
            if (e.key === 'Enter') sendMessage();
        });
    </script>
</body>
</html>

Why we do this: This HTML template creates a user-friendly chat interface for interacting with our AI agent, which is essential for enterprise adoption.

7. Run your AI agent

Start your Flask application by running:

python app.py

Open your browser and navigate to http://localhost:5000. You should see your AI agent interface.

Why we do this: Running the application starts the web server that hosts our AI agent, making it accessible through a browser interface.

Summary

In this tutorial, you've built a basic enterprise AI agent that can understand user queries and respond appropriately. You've learned:

• How to set up a Python development environment
• How to integrate with OpenAI's language models
• How to create a web interface for user interaction
• How to structure an AI agent for enterprise deployment

This simple implementation demonstrates the core concepts that companies like Wonderful use to scale AI agents across global enterprises. While this example is basic, it shows the fundamental architecture that underlies more complex enterprise AI systems.