AI for Beginners - Understanding LLMs, Tools, Assistants and Agents
In this series of articles, I will explain from the very beginning what using AI actually means. I will try to keep everything simple, using easy definitions and even simpler examples.
Why did I write this article? Because today almost everyone uses AI. People say things like:
"Ask AI”
"ChatGPT does everything for me”
"Gemini is better”
"Just prompt it”
But what does all of this actually mean?
If you want to understand how AI really works, organize your knowledge, and finally understand the AI world, you may find this article interesting.
User → AI Application → LLM
AI is not one single thing.
Most people say "I use AI”, but in reality they use a whole ecosystem: applications, language models, infrastructure, and tools.
At the beginning, there is always the user - you or me - the person who types a question or command.
Next comes the AI application (sometimes called the provider), such as:
ChatGPT (OpenAI)
Claude (Anthropic)
Gemini (Google)
Copilot (Microsoft)
OCI Generative AI (Oracle)
This is the interface that allows us to type prompts, browse chat history, search information, and interact with AI. Oracle also provides AI capabilities through Oracle Cloud Infrastructure (OCI), where developers can access foundation models, build AI-powered applications, and integrate AI services into enterprise systems.
Finally, we have the language model (Large Language Model, or LLM) - a huge neural network trained on massive amounts of text data that generates answers to our questions.
Interestingly, the same model can work inside many different applications. The model itself is basically just a service.
AI in Practice Is Just an API
If you are a developer, the previous diagram may look surprisingly familiar.
From a technical perspective, interacting with an AI model is very similar to calling a traditional REST API.
You send a request:
POST /v1/chat/completions
with data like:
{
"model": "gpt-5",
"messages": [
{
"role": "user",
"content": "Write an email to a customer"
}
]
}
And you revice a response:
{
"response": "Dear Customer..."
}
In simple terms:
The user creates a question.
The application sends the text.
The model generates a response.
The application receives the result.
The user reviews the answer and decides what to do next.
The process is much less mysterious than many people think. The same concept applies across different vendors. For example, OCI Generative AI exposes foundation models through APIs, allowing developers to send prompts and receive generated responses in a very similar way. Regardless of whether you use OpenAI, Anthropic, Google, or Oracle, the interaction pattern remains largely the same.
What Is Context?
A model only sees the information that is included in the current request.
For example:
{
"messages": [
{
"role": "system",
"content": "You are a helpful HR assistant."
},
{
"role": "user",
"content": "Write a job advertisement."
}
]
}
The model works only with the context it receives at that moment. It does not have permanent memory of previous conversations.
If an application wants the model to remember earlier messages, it must send them again as part of the current request.
This is why many AI applications include previous chat history whenever you continue a conversation.
From the model's perspective, everything it knows comes from the current context window.
Tokens
Models do not process words directly.
Instead, they process tokens.
A token is a small piece of text. It can be:
a whole word,
part of a word,
or even a single character.
For example, a short sentence may be split into several tokens before being sent to the model.
Tokens are important because they determine:
how much information fits into the context window,
how much the request costs,
how much text the model can generate.
In most AI services, you pay for input tokens (what you send) and output tokens (what the model generates).
You can estimate token usage using online tools such as Token Calculator.
AI Tools
At this point, you may be wondering:
If an LLM can only generate text, how can it send emails, create reports, or access databases?
The answer is simple: it cannot do those things by itself.
The model generates text and decisions. The actual actions are performed by tools provided by the application.
Imagine you ask: Prepare a sales report for May and send it to the sales director.
The model might decide that several steps are needed:
Retrieve sales data.
Analyze the data.
Create a report.
Save the report as a PDF.
Send an email.
To retrieve the data, the model may request a tool call such as:
{
"name": "run_sql",
"arguments": {
"query": "SELECT * FROM sales WHERE month = '2026-05'"
}
}
The application executes the query and returns the results.
The model then analyzes the data and may request another tool:
{
"name": "create_pdf",
"arguments": {
"title": "Sales Report - May 2026",
"content": "Revenue increased by 12%..."
}
}
Finally, it may ask the application to use a tool such as:
{
"name": "send_email"
}
The important thing to remember is that the model itself does not perform these actions. It decides what should happen, while the application performs the actual work. Enterprise platforms often expose these tools through business applications, databases, and cloud services. In Oracle environments, a model may interact with Oracle Database, Oracle Fusion Applications, Oracle APEX applications, or external systems through APIs and integrations.
RAG
Another concept you will often encounter is RAG, which stands for Retrieval-Augmented Generation.
Think of it as giving the model access to additional documents before it generates an answer.
For example, if you ask a question about your company's internal policies, the application may first search company documents and then include the relevant information in the model's context. The model can then generate an answer based on both its training and the retrieved documents.
This approach helps AI systems provide more accurate and up-to-date responses. In Oracle environments, Retrieval-Augmented Generation is often combined with Oracle Database 23ai and AI Vector Search. Documents can be stored as vector embeddings inside the database, allowing applications to retrieve relevant information before sending it to the language model. This approach enables organizations to build AI solutions that can answer questions using internal company knowledge while keeping data under enterprise governance and security controls.
AI Assistant
A language model is a general-purpose engine. An AI assistant gives that engine a specific role, set of instructions, knowledge, and tools. For example, you could create a customer support assistant with instructions such as:
Answer in Polish.
Be polite and concise.
Do not invent information.
Ask for missing order details.
Provide a practical next step.
You might call it: Online Store Returns Assistant
If a customer asks: I want to return a product. What should I do? The assistant can help. If someone asks: Who will win the Arsenal vs PSG match? The assistant may refuse because that topic falls outside its defined responsibilities. The model remains the same. The instructions change its behavior.
AI Agents
An AI assistant responds to questions. An AI agent goes one step further. An agent can plan and execute multiple actions to achieve a goal. Instead of simply answering a question, it can:
break a task into steps,
choose tools,
execute actions,
evaluate results,
continue working until the objective is completed
In simple terms, an AI agent is often an application that runs an LLM inside a decision-making loop. For example, imagine an Article Writing Agent.
Its instructions could look like this:
Determine the topic.
Identify the target audience.
Propose an outline.
Expand each section.
Review consistency after each major step.
Produce the final draft.
The key difference is that the agent is focused on achieving a goal rather than simply generating a single response. In practice, the line between assistants and agents is often blurry, and different companies use these terms in different ways.
MCP (Model Context Protocol)
We already know that AI models can use tools. The next question is: how do these tools become available to the model? MCP (Model Context Protocol) is an open standard that allows external systems to expose tools and data to AI applications in a consistent way.
Before MCP, integrations with systems such as GitHub, Jira, Slack, or databases were usually built separately. MCP introduces a common approach, making these integrations easier to create and maintain.
For example, if you ask: Retrieve all open Jira tickets and prepare a summary.
the model can use a tool provided through MCP to retrieve the tickets and then generate a report based on the results. In simple terms, MCP helps AI applications connect to external systems using a shared standard rather than a custom integration for every service.
AI in Oracle ecosystem
Everything described in this article can also be found within the Oracle ecosystem.
For example:
• OCI Generative AI provides access to foundation models through managed cloud services.
• Oracle Database 23ai introduces AI Vector Search, enabling efficient storage and retrieval of vector embeddings for RAG-based applications.
• Oracle Select AI allows users to query data using natural language instead of traditional SQL.
• Oracle APEX enables developers to build AI-powered applications with relatively little code.
• Oracle Digital Assistant provides enterprise assistants that can integrate with business systems and automate user interactions.
Although the products differ, the underlying concepts remain the same: prompts, context, tokens, tools, RAG, assistants, agents, and integrations.
Summary
Artificial Intelligence is not a magical entity. It is a collection of technologies working together: AI applications such as ChatGPT or Gemini, language models (LLMs), context, tokens, tools, assistants, agents, and standards such as MCP.
By itself, a language model can only generate text. However, with access to additional documents through RAG, external tools, and agent-based workflows, it can perform much more complex tasks and help automate real work.
Understanding these building blocks makes it easier to understand how modern AI systems work, what they can do, and where their limitations come from.
I hope this article helped you better understand the world of AI.
