Skip to content
Lesson 5 of 5

Practical Applications and the Future

3 min read

From Models to Applications

A raw LLM is impressive but limited — it can only work with what it learned during training. The real power comes from techniques that extend and customize these models for specific use cases.

RAG: Retrieval-Augmented Generation

The problem: LLMs have a knowledge cutoff and can hallucinate facts. You need answers grounded in your own data.

The solution: Before generating a response, retrieve relevant documents from a knowledge base and include them in the prompt as context.

RAG pipeline:

  1. Index: Chunk your documents and create embeddings (vector representations)
  2. Retrieve: When a user asks a question, find the most relevant chunks using vector similarity
  3. Generate: Pass the question + retrieved chunks to the LLM to generate a grounded answer

RAG is the most practical way to give an LLM access to private, up-to-date, or domain-specific knowledge without retraining the model.

Fine-Tuning: When RAG Isn't Enough

Sometimes you need the model to behave differently, not just access new information. Fine-tuning adjusts the model's weights on your specific data.

When to fine-tune:

  • Consistent formatting or style requirements
  • Domain-specific terminology and reasoning patterns
  • Specialized tasks (medical diagnosis, legal analysis)
  • When RAG retrieval quality is insufficient

Methods:

  • Full fine-tuning: Update all parameters (expensive, risk of catastrophic forgetting)
  • LoRA/QLoRA: Update only small adapter layers (efficient, preserves base knowledge)
  • SFT + DPO/RLHF: Fine-tune for specific behaviors using preference data

A practical example: Guarani-LM fine-tuned Qwen2.5-0.5B with QLoRA to create the first open-source LLM for the Guarani language.

Autonomous Agents

The frontier of AI application: agents that can plan, use tools, and execute multi-step workflows autonomously.

An AI agent typically has:

  • Reasoning: An LLM as the "brain" that plans and decides
  • Tools: APIs, code execution, web browsing, file access
  • Memory: Conversation history, retrieved context, learned preferences
  • Execution loop: Plan → Act → Observe → Plan again

Frameworks like LangChain, CrewAI, and Claude's tool-use API enable building agents that can research topics, write code, manage infrastructure, and more.

For an example of an autonomous agent, see Arandu — an AI agent with terminal, browser, and editor capabilities running inside sandboxed Docker containers.

MCP: The Standard for AI Tool Use

The Model Context Protocol (MCP) is becoming the universal standard for how AI models connect to external tools. Think of it as USB-C for AI — a single protocol that lets any model use any tool.

An MCP server exposes tools that AI models can call. For example, MCP-Vanguard provides 89 pentesting tools through MCP, while InfraOps-MCP offers 92 infrastructure management tools.

MCP is now governed by the Linux Foundation and adopted by every major AI provider. If you build tools for AI, building MCP servers is the future-proof approach.

What's Next?

The field is moving toward:

  • Multi-agent systems: Teams of specialized agents collaborating on complex tasks
  • Computer use: AI that can operate GUIs directly (mouse, keyboard)
  • Continuous learning: Models that update their knowledge without full retraining
  • Reasoning models: Architectures optimized for multi-step logical reasoning
  • Multimodal agents: AI that sees, hears, reads, and acts across all modalities

We're at the beginning of the agentic era. The models exist, the protocols are standardizing, and the tools are maturing. What we build with them is up to us.