How to implement AI in a project without rewriting the architecture

You are working on a project, and suddenly an idea pops up: "What if we add AI here?". It's a cool idea, but you're immediately afraid that you'll have to rewrite everything, change the architecture, and spend months on refactoring. I hasten to please you: in most cases this is not required.

Modern artificial intelligence tools are designed to easily integrate into existing applications. Let's figure out how to do it correctly and painlessly.

Define the task for AI

Before you implement anything, you need to understand why you need AI at all. Don't add it just because it's trendy — it should solve a specific problem for your users.

Typical tasks where AI is really useful: generating texts for product descriptions, automatic content classification, smart database search, recommendations to users, image processing, chatbots for customer support, and analysis of the tone of reviews.

Choose one task to start. Don't try to implement AI everywhere at once — this is the path to chaos and over-complication.

Use API instead of local models

The easiest way to add AI to a project is to use ready-made APIs. You don't need to understand how neural networks work, train models, or buy powerful servers with video cards.

Popular solutions include the OpenAI API for working with text, Anthropic Claude API as an alternative, Google Cloud Vision for image recognition, AWS Rekognition for photo and video analysis, and Hugging Face Inference API for various tasks.

Working with the API looks like a regular HTTP request. Here is a simple example in PHP:

function generateDescription($productName) {
    $apiKey = getenv('OPENAI_API_KEY');
    
    $data = [
        'model' => 'gpt-4',
        'messages' => [
            [
                'role' => 'user',
                'content' => "Write a short description of the product: $productName"
            ]
        ]
    ];
    
    $ch = curl_init('https://api.openai.com/v1/chat/completions');
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Authorization: Bearer ' . $apiKey,
        'Content-Type: application/json'
    ]);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    
    $response = curl_exec($ch);
    curl_close($ch);
    
    $result = json_decode($response, true);
    return $result['choices'][0]['message']['content'];
}

In JavaScript, it's even easier using fetch. You just call the function and get the result — no magic, no changes in the architecture.

Create a separate service wrapper

To avoid spreading the logic of working with AI throughout the project, create a separate class or module that will be responsible for interacting with the API.

Example of a structure in PHP:

class AIService {
    private $apiKey;
    private $apiUrl;
    
    public function __construct() {
        $this->apiKey = getenv('OPENAI_API_KEY');
        $this->apiUrl = 'https://api.openai.com/v1/chat/completions';
    }
    
    public function generateText($prompt, $maxTokens = 150) {
        // API request logic
        return $this->makeRequest($prompt, $maxTokens);
    }
    
    public function analyzeImage($imageUrl) {
        // Another method for working with images
    }
    
    private function makeRequest($prompt, $maxTokens) {
        // General logic of an HTTP request
    }
}

Now you can use this service anywhere in the project. If you later want to change the AI provider or change the processing logic, you will only need to edit the code in one place.

Add caching

API requests cost money and take time. If a user requests the same information twice, there is no point in contacting the AI again — you can return the cached result.

A simple example using Redis:

class AIService {
    private $redis;
    
    public function generateText($prompt, $maxTokens = 150) {
        $cacheKey = 'ai_' . md5($prompt . $maxTokens);
        
        // Checking cache
        if ($cached = $this->redis->get($cacheKey)) {
            return $cached;
        }
        
        // If not in the cache, make a request
        $result = $this->makeRequest($prompt, $maxTokens);
        
        // Saving for an hour
        $this->redis->setex($cacheKey, 3600, $result);
        
        return $result;
    }
}

Even if you don't have Redis, you can use a file cache or a database — the main thing is not to make unnecessary requests.

Handle errors correctly

The API may crash, the request limit may run out, the Internet may disappear. Your application should work correctly even when AI is not available.

Always wrap requests in try-catch, set timeouts, and provide backup options. If the AI could not generate a product description, you can show a standard template or leave the field blank — but the application should not crash.

public function generateText($prompt, $maxTokens = 150) {
    try {
        $result = $this->makeRequest($prompt, $maxTokens);
        return $result;
    } catch (Exception $e) {
        // Logging an error
        error_log('AI API Error: ' . $e->getMessage());
        
        // Return the default value
        return "Description temporarily unavailable";
    }
}

Use queues for heavy tasks

If processing takes a long time - for example, analyzing a large image or generating detailed text - do not make the user wait. Send the task to the queue and process it asynchronously.

In PHP, Laravel Queue or Symfony Messenger will work for this, in Node.js you can use Bull or RabbitMQ. The user will be notified when the task is completed.

// Sending to the queue
dispatch(new GenerateProductDescription($productId));

// Processing in the worker
class GenerateProductDescription implements ShouldQueue {
    public function handle(AIService $ai) {
        $product = Product::find($this->productId);
        $description = $ai->generateText("Description for: " . $product->name);
        
        $product->update(['ai_description' => $description]);
    }
}

Store results in a database

Don't generate content every time. If the AI has created a product description, save it in the database. This will speed up the application and save money on the API.

Add a new field to the table, for example ai_generated_description, and write the result there. The next time you make a request, just get it from the database.

Give the user control

The results of AI work are not always perfect. Always allow the user to edit or reject the generated content.

You can add a "Generate description" button and an editable field next to it. The user will see a proposal from the AI and will be able to modify it — this is better than fully automatic generation without control.

Start small

Don't try to implement AI in all parts of the application at once. Choose one small function, implement it, and test it on real users.

If everything works well, expand the functionality. If something went wrong, you have lost a minimum of time and can quickly roll back the changes.

Keep track of your budget

APIs are not free. OpenAI, Claude, and other services charge money for each request. Set limits, monitor expenses, and set up alerts.

You can limit the number of requests per user per day or cache popular requests more aggressively. The main thing is that the introduction of AI does not lead to unexpected bills for thousands of dollars.

Keep your data private

When you send data to a third-party API, it leaves your server. Make sure you do not share users' personal data, passwords, or payment information.

Read the API provider's user agreement and comply with GDPR or other data protection laws if they apply to your project.

Implement gradually

You can add AI functions one after another without touching the existing code. Today, autogeneration of descriptions, in a month — smart search, in another month — a recommendation system.

This approach allows you to adapt to changes, learn from mistakes and not overload the development team. The architecture remains the same, but the application becomes smarter.

The introduction of AI into an existing project is not about a total restructuring of the system. It's about carefully adding new features that make the product better for users. Start small, use ready-made tools, keep an eye on quality and budget — and you'll be surprised how easy it can be.

You can learn different programming languages on the platform Code — we have structured courses for beginner developers.

And also join our Telegram channel, where a friendly community of programmers has gathered, always ready to help with advice and share their experience!