Quick answer: An LLM (large language model) is a neural network trained on huge amounts of text to predict the next token in a sequence. That single skill, done at scale, produces something that can write, summarize, translate, and answer questions. But an LLM only knows what was in its training data, so for anything current or private it needs external tools and retrieval.
I want to give you the honest version of this, not the marketing one. LLMs are genuinely useful and genuinely limited, and understanding both halves is what separates people who ship reliable AI products from people who ship demos that fall apart in front of a real user.
What an LLM Actually Does
At the core, a large language model does one thing: given some text, it predicts what comes next.
You feed it a sequence of tokens (roughly, pieces of words), and it outputs a probability distribution over what the next token should be. It picks one, appends it, and repeats. That loop is the whole trick. Everything else, the fluent essays and the working code, is an emergent property of doing next-token prediction really well across trillions of examples.
This matters because it explains the model's behavior. An LLM is not looking things up in a database. It is not reasoning from a set of stored facts. It is generating plausible continuations based on statistical patterns it learned during training. Most of the time plausible and correct line up. Sometimes they do not, and that gap is where hallucinations come from.
How LLMs Are Trained
Training happens in two broad phases.
Pretraining. The model reads an enormous corpus of text (web pages, books, code, and more) and learns to predict masked or next tokens. This is where it picks up grammar, facts, coding patterns, and a rough model of how the world tends to be described. Pretraining is expensive and slow, which is why models have a training cutoff date. After that date, the model knows nothing.
Post-training. Once the base model exists, it gets refined to be useful and safe. Techniques like supervised fine-tuning and reinforcement learning from human feedback teach it to follow instructions, answer helpfully, and refuse harmful requests. This is the difference between a model that autocompletes your sentence and one that acts like an assistant.
The key takeaway: training bakes knowledge in at a fixed point in time. The model is a snapshot.
What LLMs Are Good At
LLMs shine at tasks that are fundamentally about language and pattern:
- Summarizing long documents
- Rewriting text in a different tone or format
- Translating between languages
- Extracting structured data from messy text
- Writing and explaining code
- Answering questions about widely-documented topics
- Classifying and tagging content
If a task can be framed as "turn this text into that text," an LLM is probably a strong fit.
What LLMs Cannot Do (Without Help)
Here is where people get burned.
| Limitation | Why it happens | The fix |
|---|---|---|
| No knowledge past the training cutoff | Training is a one-time snapshot | Retrieval / web search |
| No access to private or internal data | Your docs were never in training | Retrieval over your own sources |
| Can state falsehoods confidently | It predicts plausible text, not verified facts | Ground answers in cited sources |
| Cannot take real actions | It only outputs text | Tool calling |
| Fixed memory per request | Limited context window | Careful context management |
An LLM by itself is a closed book. It cannot check today's stock price, read your company wiki, or send an email. To do any of that, you have to connect it to the outside world.
Why LLMs Need Tools and Retrieval
Two capabilities turn a raw LLM into something you can build a product on.
Tool calling lets the model request an action. Instead of guessing an answer, it emits a structured request like "search the web for X" or "look up order 12345," your code runs that, and the result goes back into the conversation. This is how an LLM gets internet access and how it takes actions in the real world. We cover the mechanics in what is tool calling in LLMs.
Retrieval feeds the model relevant, current information at request time. Rather than hoping the answer was memorized during training, you fetch the right documents, drop them into the prompt, and ask the model to answer from them. This pattern is called RAG, and it is the single most reliable way to reduce hallucinations. See what is RAG for a full walkthrough.
Both patterns depend on getting clean data into the model. That is a harder problem than it sounds, because most of the web is messy HTML full of navigation menus, ads, and scripts. This is where a service like link.sc fits in: one API call turns any URL into clean markdown or does a web search that returns full page content, so the model sees the actual information instead of raw markup.
Here is what feeding fresh data to a model looks like in practice:
curl -X POST https://api.link.sc/v1/fetch \
-H "x-api-key: lsc_your_key_here" \
-H "Content-Type: application/json" \
-d '{"url": "https://example.com/latest-report", "format": "markdown"}'
The response comes back as {"content": "..."} with clean markdown you can inject straight into a prompt. No parsing, no dead scripts, no boilerplate.
A Mental Model That Holds Up
Think of an LLM as a brilliant contractor who has read almost everything ever written, but who has been in a room with no windows since their training cutoff, and who cannot leave the room or make phone calls.
They can reason about anything you describe to them. They can write beautifully. But if you want them to work with current facts or your private information, you have to bring those materials into the room. And if you want them to actually do something outside the room, you have to be their hands.
That framing tells you where to invest. The model is rarely the bottleneck. The bottleneck is usually the quality of the information you feed it and the tools you give it. Grounding answers in live sources, which we cover in ground LLM answers in live web sources, often does more for output quality than swapping to a bigger model.
Where to Go From Here
If you are building with LLMs, the concepts that matter most in practice are the context window (how much the model can read at once), tokens (the billing and limits unit), tool calling, and retrieval. Start there rather than obsessing over which model is a few points higher on a benchmark.
An LLM is a prediction engine with a snapshot of the past baked in. Connect it to good data and real tools, and it becomes something genuinely capable. Leave it isolated, and you get confident guesses. The difference is entirely in the plumbing you build around it.
Building an LLM app that needs fresh, clean web data? link.sc gives your model one API to fetch and search the web. Start free.