AI Is More Than Just Training Models

In recent months, everyone has been talking about AI. But behind this word, what does it actually mean? Since I started training in AI development, I've discovered that there are several realities: traditional machine learning, deep learning models, generative AI... and above all, a considerable gap between what we learn to build and what businesses actually use.

Yet, despite these differences, one element remains central: data. Regardless of the method used -- whether machine learning, neural networks, or generative AI -- they all rely on exploiting vast volumes of data. Data is what shapes models, refines their predictions, and enables them to generate relevant content. Without data, there is no AI. And it is precisely the quality, diversity, and management of this data that determines the relevance and effectiveness of the solutions deployed in businesses.

As an apprentice AI developer, I face both educational projects (where we train a lot of models) and real-world business needs (where AI is mostly consumed via APIs). "Doing AI" doesn't mean the same thing depending on the context. Between the models we train by hand during our coursework and the ready-made solutions I observe in the workplace, there is a whole world. And it is precisely in this gap that the real challenges of AI integration lie today.

Machine Learning: The Invisible Foundations of AI

Learning to train a model means understanding what AI truly is. You handle data, analyse it to match the need, adjust parameters, do feature engineering... Every adjustment, every choice of feature directly influences the model's performance. This tuning process, while essential, is often also a game of trial and error where experience and domain knowledge make all the difference. In short, you create tailor-made "intelligence".

This work is slow, expensive, and fragile. It takes time, resources, and a very good understanding of the domain. During my training, I trained models to predict the severity of road accidents or the price of a property. Each time, it was necessary to explore the data, analyse it, clean it when it was unusable (missing values, biased data, etc.), design relevant features, choose an algorithm, transform the data if needed, test, evaluate with the right metrics, and readjust. That's where you truly understand what "training a model" means: a careful blend of statistical rigour, iterations, and resources... which you don't always have.

Understanding AI means diving into machine learning. Learning to develop AI means first learning to handle data. Lots of data. Cleaning, sorting, enriching, splitting, transforming... which takes approximately 70% of the working time. This foundational work, invisible to the end user, is nevertheless essential.

It is this mastery of machine learning that forms the foundation on which more complex models rest: without good data management and solid fundamentals, advanced AI could not exist.

The Challenges of Model Training

• Data volume and complexity
• Limited resources
• Data quality issues
• Complex technical choices

Training an AI model involves several major challenges. Data volume and complexity play an essential role: restricting the dataset speeds up training but can impair the model's ability to generalise well. A GridSearchCV, for example, can become very costly in time if the dataset is too large.

Limited resources are also a constraint. Working on a simple laptop with computationally intensive tasks is often impractical. Alternatives like cloud computing or GPU optimisation exist, but their cost can limit accessibility for small businesses or freelancers.

Data quality is a critical factor that is often underestimated. Outliers, missing values, scaling issues, and bias directly impact model performance. This cleaning work is time-consuming but essential for obtaining a reliable model.

Finally, technical choices strongly influence results. RandomForest or XGBoost? Linear regression or neural network? Each approach has implications for model performance and interpretability, and requires careful analysis before being adopted.

Traditional Machine Learning vs. Deep Learning: Two Different Worlds

During my training, I first learned classical algorithms (regression, decision trees, SVM...) before diving into deep learning. And I quickly understood that these are two fundamentally different approaches.

To better understand this difference, here are two typical approaches: a classic machine learning model and a deep learning neural network.

Example of a machine learning model:

Example of a neural network:

The first example uses scikit-learn, ideal for classic problems with reasonably sized datasets. The second, using TensorFlow, is typical of deep learning: more parameters, more complexity, but potentially more power for unstructured or very large data.

Classic models are often preferred for their interpretability, whereas neural networks offer more power but are harder to explain. In addition to their complexity, neural networks require significantly more computing power, which explains the preference for cloud environments or GPU-equipped machines.

Pre-trained AI: The Quick Option, but Not Always Under Control

In business, you don't always train your own models. In many cases, AI is accessed via APIs: ChatGPT, Claude, Gemini... These are "agents" capable of generating text, interacting with users, and summarising documents. It's quick to integrate. But the challenge then becomes: how do you control their behaviour?

Challenges of Using Pre-trained AI

• Behaviour control
• Lack of transparency
• Vendor dependency
• Limited customisation
• Hidden integration costs
• Ethical and legal concerns
• Environmental concerns

Using pre-trained AI poses several challenges. Behaviour control is a major concern: adjusting prompts and framing the context is essential to obtain coherent responses and avoid drift.

The lack of transparency is also problematic. Many models operate as a black box, making it difficult to understand the decisions made by the algorithm.

Vendor dependency is a risk to anticipate: pricing changes, new terms of use, or service discontinuation can impact a company's operations.

On the customisation front, generalist models may misinterpret the specifics of a domain or use inappropriate vocabulary.

Hidden integration costs are often underestimated. Beyond the cost per token, you need to account for service latency, the adjustments required to ensure response quality, and additional development to handle errors and technical constraints.

Finally, there is an ethical and legal concern: what happens to the processed data? How can confidentiality be guaranteed? More and more regulations are emerging to oversee these uses. While GDPR governs the protection of personal data, the AI Act aims to regulate the use of artificial intelligence systems based on their risk level. It does not yet set a strict framework for all AIs, but defines categories ranging from minimal risk to unacceptable risk.

The environmental impact is also concerning. Data centres that host and train these models consume massive amounts of energy and water, generating a significant carbon footprint. The heat generated by this infrastructure requires intensive cooling systems, further increasing their ecological impact. Facing these challenges, some companies are exploring solutions such as reusing waste heat or CO2 capture, but these initiatives remain marginal. As AI becomes more widespread, the question of its sustainability becomes a central issue.

Here is a concrete example of integrating a generative AI API into a Python application:

This code illustrates several important points:

• Error handling and retries, essential in production
• The separation between user prompt and system message
• Tuning parameters like temperature that influence the creativity of the response

Developing with AI: Between Microservices, Prompts, and RAG

Today, you no longer develop an AI. You develop around it. You create an API, an interface, a microservice that connects to an agent via a request, you vectorise documents, you build workflows (LangChain, LangGraph, etc.). It's a new form of programming. You "steer" an existing intelligence towards a specific task.

The role of the AI developer is evolving: it's no longer so much about training models as it is about leveraging them intelligently within existing workflows. Now, mastering LangChain, vector databases, and orchestration is becoming just as important as knowing learning algorithms.

Focus on Key Concepts

• LangChain and LangGraph
• Vector databases and embeddings
• RAG (Retrieval Augmented Generation)

The challenge is less scientific than it is about design.

The LangChain and LangGraph frameworks allow you to orchestrate interactions with LLMs, chain actions together, and build complex pipelines. They are essential for structuring an AI's responses while improving the contextualisation and logic of interactions.

Vector databases and embeddings are advanced techniques that transform the meaning of words and sentences into mathematical vectors, enabling semantic searches and retrieving relevant information to feed the AI.

Finally, RAG (Retrieval Augmented Generation) improves the reliability of AI-generated responses by drawing on external knowledge bases. This reduces hallucinations and ensures more accurate, factual answers -- particularly useful for technical assistants and decision-support systems.

Unlike classic RAG approaches that simply retrieve documents and pass them to an LLM, an Agentic RAG goes further: it integrates decision-making mechanisms, filtering, and intelligent query reformulation. The goal? To optimise the relevance of the retrieved information and reduce potential errors.

In our project, a simple RAG wasn't enough: press articles often contain complex and sometimes ambiguous information, requiring better contextual understanding before being used. To address these limitations, we adopted an Agentic RAG approach, capable of improving response relevance and limiting errors through a combination of several techniques:

Agentic RAG System Architecture

1. Loading and segmenting press articles

   • Extracting relevant texts
   • Splitting into segments for better indexing

2. Document vectorisation

   • Using embeddings to represent the meaning of texts
   • Storing in a vector database (e.g., FAISS, ChromaDB)

3. Intelligent retrieval agent

   • Query reformulation to improve relevance
   • Filtering results to avoid irrelevant information

4. Integration with an LLM via API

   • Generating responses based on retrieved documents
   • Verifying the consistency and reliability of responses

5. Orchestration with LangChain and LangGraph

   • Setting up a dynamic workflow to manage interactions
   • Using LangGraph to structure the retrieval and generation steps

The result? An assistant capable of answering questions about the content of press articles while citing its sources. This is far more powerful and accurate than a simple API call.

The Art of Prompting: A Critical Skill

Prompting an AI is not just about asking a question.

Keys to an Effective Prompt

• Precision and conciseness: Be clear about the desired role, task, format, and tone.
• Contextualisation: Provide all the information the AI needs to understand the request.
• Constraints and examples: Define the boundaries of the response and give examples of what is expected.
• Iteration and experimentation: Adjust the prompt based on the results obtained.

Here is an example of a system prompt I developed for a literary chatbot, illustrating best practices for effectively guiding AI in searching for and presenting information:

SYSTEM PROMPT:

You are a literary assistant specialised in searching for information from provided documents or via web search tools. Your role is to answer users' questions about literary works, authors, or literary concepts.

IMPORTANT RULES:

1. Prioritise information contained in the provided documents (CONTEXT).
2. If the information is not available in the context, use the web search tool to find relevant answers.
3. Always cite your sources (file name or URL) if you use external information.
4. Your responses should be concise (max 3 paragraphs) and informative.
5. If you cannot find relevant information, say so clearly.

RESPONSE FORMAT:

1. Start with a sentence confirming your understanding of the question.
2. Present the found information clearly and in a structured manner.
3. Indicate the source of the information.
4. If relevant, suggest additional avenues for research.

RESPONSE EXAMPLE:

User question: "Who is the main character of 'Madame Bovary'?"

AI response: "You are asking about the main character of 'Madame Bovary'. The main character of this novel by Gustave Flaubert is Emma Bovary, a married woman who dreams of a romantic and passionate life, inspired by her readings. Her disillusions and her attempts to escape the monotony of her existence are at the heart of the story. Source: General knowledge about the work."

CONTEXT: {context} (literary information from files)

This prompt highlights the definition of the literary assistant role:

• The importance of prioritising information sources
• Citing sources
• A structured and informative response format
• Handling cases where information is not found

The integration of a web search tool is also accounted for in the rules.

This prompt perfectly illustrates best practices:

• Clear role definition
• Precise instructions on the expected format
• Concrete examples
• A mechanism for integrating context (documentation)

The quality of AI-generated responses does not depend solely on the model, but also on the precision of the prompt. A good prompt can transform a vague response into effective, targeted assistance.

Train or Consume: A Strategic Choice

Training a model remains essential for certain use cases (healthcare, industry, finance...). But it requires significant resources. Many companies therefore prefer to consume intelligence that is already available. Knowing how to train a model remains useful -- especially for understanding how to manipulate it intelligently.

When to Favour Training a Custom Model?

• Sensitive data
• Highly specific problems
• Need for total control
• Processing volume
• Evolving practices

Training a custom model is essential when data is sensitive and cannot leave the company's infrastructure. This ensures better privacy and regulatory compliance.

For highly specific problems, generic models sometimes struggle to understand the business context. In these cases, a custom-built model improves the relevance of predictions and adaptation to precise needs.

Another key factor is the need for total control. Some companies must be able to audit how the model works, explain its decisions, or guarantee complete data traceability.

Processing volume can also make using AI APIs expensive. At scale, training an internal model becomes more economical and helps avoid excessive dependency on external providers.

Finally, with evolving practices, many organisations are adopting high-performing open-source models and training them on their own data. This approach strengthens technical mastery and reduces risks associated with changes to external API conditions.

When to Favour API Consumption?

• Time-to-market
• Generic features
• Experimentation
• Limited resources

Pre-trained AI via APIs reduces time to production. Rather than spending months training a custom model, a company can quickly integrate an existing solution to meet an immediate need. This is a strategic choice for projects where deployment speed is essential.

Generic features such as translation, sentiment classification, or text generation are often well covered by pre-trained models. This avoids having to create and train a custom model, optimising costs and efficiency.

AI APIs are also an excellent experimentation tool. They allow you to test a use case before investing in a custom solution, facilitating feasibility validation and project interest without tying up too many resources.

Finally, for companies with limited resources -- tight budgets, no GPU infrastructure, or a lack of internal expertise -- APIs offer an accessible solution without the technical complexity of model training.

Hybrid Approaches

In practice, many companies adopt a hybrid approach: they leverage APIs for routine tasks and train their own models when business requirements demand customisation or total control.

If the decision to train or consume an AI model is based on technical and strategic criteria, it is also strongly influenced by economic considerations. Behind each option lie costs that are sometimes underestimated, directly impacting the profitability of an AI solution.

Maintenance: The Hidden Cost of Models

An often-overlooked aspect is the maintenance of AI models. Once deployed, a model is not immutable. It must be monitored, evaluated, and sometimes retrained to maintain its performance.

For Internally Trained Models

• Implement performance monitoring
• Detect concept drift
• Periodically retrain with new data
• Manage model versions
• Establish MLOps (Machine Learning Operations) practices

An internally trained AI model requires rigorous performance monitoring to ensure it remains relevant over time. This includes tracking key metrics and adjusting parameters if prediction quality drops.

Concept drift is a major risk. If the data distribution changes, the model can gradually become obsolete. For example, a stock market prediction model based on historical trends could lose effectiveness in the face of sudden market changes.

Periodic retraining with new data helps adapt the model to recent developments and preserve its reliability.

Version management is essential for tracking different model iterations, comparing performance, and rolling back to a previous version if problems arise.

Finally, integrating MLOps practices automates part of these tasks, ensuring continuous performance monitoring and triggering retraining based on defined thresholds.

For AI APIs

• Monitor API changes and pricing
• Adapt prompts to new model versions
• Regularly test critical cases to detect regressions
• Plan fallback solutions in case of malfunction, unavailability, or API failure

An AI model is never a finished product: its maintenance involves costs in infrastructure, expertise, and data updates. For API-based solutions, you need to anticipate pricing variations and technological changes imposed by the provider.

The Real Costs of Artificial Intelligence

Beyond maintenance and hidden costs, AI represents a heavy investment in infrastructure and computing power. Depending on the chosen approach, these costs can vary considerably:

• Storage and infrastructure costs
• Computing power and GPU resources
• Licence and specialised tool costs
• Energy consumption and ecological footprint

Internally trained models require significant storage capacity to host datasets, checkpoints, and model versions. This often involves dedicated servers or cloud solutions, whose costs can quickly escalate.

Training an AI model demands massive computing power, especially for deep learning models. GPUs (or even TPUs) are essential for accelerating these calculations, but their acquisition and usage costs can be prohibitive.

Some platforms offer optimised training environments (such as Azure ML, AWS SageMaker, Google Vertex AI). While they simplify the process, they involve subscription fees and sometimes costs related to internal API usage, which can increase the budget at scale.

Finally, an often-underestimated factor: the energy impact of AI training. Data centres consume enormous amounts of electricity, and some models require thousands of hours of computation, increasing the carbon footprint.

Conversely, using an AI API allows you to outsource these costs. The company pays per use (e.g., cost per token), without having to manage infrastructure or energy consumption. But beware of hidden fees: the volume of requests can quickly make this option more expensive than expected!

AI Is a Tool, Not a Magic Promise

What I take away from these experiences is that developing an AI application is not just about coding a deep learning model. It's primarily about meeting a need: automating a task, extracting information, predicting behaviour, etc. And to achieve this, the model doesn't do everything. You need to think about the overall architecture, the interface, inputs and outputs, data security, business logic, edge cases, scalability...

In other words, AI is not an end in itself. It's a component of a larger system.

Designing an effective AI solution is therefore much more than creating a high-performing model: an AI model, however advanced, only has value if it integrates effectively into a technical and business ecosystem. It must coexist with databases, APIs, management systems, and analytics tools to produce real impact.

And whether that component is trained in-house or called via API, what matters is knowing how to integrate it intelligently.

A Skill in Its Own Right: Choosing the Right Level of AI

Ultimately, knowing how to code a model is essential for understanding the underlying mechanisms. But in practice, the true skill of an AI developer is knowing how to choose the right solution for the right use case. Is a pre-trained model sufficient? Should it be fine-tuned with specific data? Should a custom model be trained? Or should AI be bypassed entirely in favour of simple rules?

It's this ability to step back that interests me today. AI is a fascinating but demanding field. It requires navigating between the rigour of code, mastery of data, domain knowledge... and a certain humility in the face of tools that are as powerful as they are unpredictable. Mastering AI is not about trying to tame it entirely, but learning to guide its unpredictability while accepting that it retains a degree of autonomy. Like a spirited horse, it can surprise you, but rather than trying to control everything, you need to know when to let go while putting guardrails in place to channel its energy and steer its responses intelligently.

And what if, tomorrow, the role of AI developers was no longer to create models, but to understand, assemble, and govern them?