A plain-English guide to every major GenAI framework, tool, and concept — with resources to go deeper on each one
If you've been trying to follow the GenAI space lately, you've probably felt like you need a decoder ring just to keep up. MCP, A2A, ADK, RAG, LangChain, AutoGen, CrewAI — every week there's a new acronym, a new framework, a new "paradigm shift."
Here's the truth: most of these things are solving the same core problem from different angles. Once you understand the big picture, everything clicks into place.
This article is your map. We'll cover every major framework, protocol, and concept in the GenAI ecosystem — what each one is, why it exists, and exactly where to go to learn it. No PhD required.
The Big Picture: What Are We Actually Building?
Before diving into frameworks, let's understand the problem they're solving.
A raw LLM (like GPT-4 or Claude) is essentially a very smart text predictor. You give it text, it gives you text back. That's powerful, but it has serious limitations out of the box:
- It can't browse the internet or access real-time data
- It can't run code, query databases, or call APIs
- It can't remember your previous conversations
- It can't coordinate with other AI models
- It forgets everything between sessions
Every framework in this article exists to solve one or more of these limitations. Keep that in mind as we go through them — it'll make each one instantly make sense.
Part 1: The Foundation — How LLMs Actually Work
Before frameworks, you need a mental model of what an LLM is doing.
What is a Large Language Model?
An LLM is a neural network trained on billions of pages of text. During training, it learned patterns — how words, ideas, and concepts relate to each other. When you prompt it, it's not "thinking" in the human sense — it's predicting the most statistically likely continuation of your text, based on everything it absorbed during training.
The magic is that predicting text at scale, with enough data and compute, produces something that looks remarkably like reasoning.
Key concepts to understand:
- Context window — the amount of text the model can "see" at once (its working memory). GPT-4 has a 128K token window; Claude has up to 200K.
- Temperature — controls how creative/random the output is. 0 = deterministic, 1 = creative, 2 = chaos.
- Tokens — how LLMs read text. "ChatGPT" = 2 tokens. Rule of thumb: 1 token ≈ 0.75 words.
- Embeddings — numeric representations of text meaning. Two sentences with similar meaning have similar embeddings. This is the backbone of semantic search and RAG.
Resources to go deeper:
- 3Blue1Brown — But what is a GPT? ← best visual explanation on the internet
- Andrej Karpathy — Intro to Large Language Models
- OpenAI Tokenizer ← play with tokens interactively
Part 2: Prompt Engineering — Talking to LLMs Effectively
Before you touch any framework, you need to understand prompt engineering. It's the skill of getting LLMs to do what you actually want.
Core Techniques
Zero-shot prompting — just ask, no examples:
Classify this review as positive or negative: "The food was cold and tasteless."
Few-shot prompting — show examples before asking:
Review: "Amazing food!" → Positive
Review: "Waited 2 hours" → Negative
Review: "The food was cold and tasteless." → ?
Chain-of-thought (CoT) — ask it to think step by step:
Solve this step by step: If a train travels 60mph for 2.5 hours...
System prompts — give the model a persona and set of rules it follows throughout the conversation. Every production application uses these.
Resources:
- Anthropic Prompt Engineering Guide
- OpenAI Prompt Engineering Guide
- Learn Prompting ← free, comprehensive, beginner-friendly
Part 3: RAG — Giving LLMs Your Own Knowledge
RAG (Retrieval-Augmented Generation) is one of the most important and practical techniques in the entire GenAI stack.
The Problem RAG Solves
LLMs are trained on data up to a cutoff date. They don't know about your company's internal documents, your codebase, last week's news, or anything that happened after training. RAG fixes this.
How RAG Works
Think of it like an open-book exam vs. a closed-book exam. Without RAG, the LLM has to answer from memory alone. With RAG, it can look things up first.
The flow:
- Ingest — take your documents (PDFs, websites, databases) and split them into chunks
- Embed — convert each chunk into a vector (a list of numbers representing meaning)
- Store — save those vectors in a vector database
- Query — when a user asks a question, convert it to a vector and find the most similar chunks
- Generate — send those chunks + the question to the LLM. It answers using the retrieved context.
Vector Databases
This is where your embeddings live. Major options:
| Database | Best for | Free tier? |
|---|---|---|
| Pinecone | Production, scale | Yes |
| Chroma | Local development | Yes (local) |
| Weaviate | Open source, self-hosted | Yes |
| pgvector | Already using Postgres | Yes |
| Qdrant | High performance | Yes |
Resources:
Part 4: AI Agents — LLMs That Can Act
This is where things get exciting. An AI agent is an LLM that can take actions in the real world — not just generate text.
What Makes Something an "Agent"?
An agent has three things a basic LLM call doesn't:
- Tools — functions it can call (search the web, run Python, query a database, send an email)
- Memory — some form of state across multiple steps
- Planning — the ability to break a complex goal into steps and execute them in sequence
The most common agent pattern is ReAct (Reasoning + Acting):
Thought: I need to find the current price of Apple stock
Action: search_web("AAPL stock price today")
Observation: Apple stock is trading at $189.30
Thought: Now I can answer the question
Answer: Apple stock is currently $189.30
The model reasons about what to do, takes an action, observes the result, and repeats until it has an answer. This loop is the heartbeat of every agent framework.
Agentic Flows
Agentic flows (sometimes called agentic pipelines or workflows) are structured sequences where LLM calls are chained together, with the output of one step feeding into the next. Think of it as assembly-line AI — each station does one job well.
Common patterns:
- Sequential — step 1 → step 2 → step 3 → done
- Parallel — multiple agents run simultaneously, results are merged
- Router — an orchestrator decides which specialized agent handles a request
- Evaluator-optimizer — one agent generates, another critiques, repeat until quality threshold is met
Part 5: The Major Frameworks
Now let's go through every major framework you'll encounter.
LangChain
What it is: The most widely adopted LLM application framework. Provides building blocks for chains, agents, memory, and RAG pipelines in Python and JavaScript.
Best for: RAG pipelines, document Q&A, building agents with tools, prototyping quickly.
Key concepts: Chains, Runnables, LangGraph (for complex agent workflows), LangSmith (for observability).
Quick example:
from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate
llm = ChatAnthropic(model="claude-3-5-sonnet-20241022")
prompt = ChatPromptTemplate.from_template("Explain {topic} to a 10-year-old")
chain = prompt | llm
response = chain.invoke({"topic": "neural networks"})
Resources:
LlamaIndex
What it is: Focused specifically on data — connecting LLMs to your own data sources. While LangChain is broad, LlamaIndex goes deep on the ingestion, indexing, and retrieval side.
Best for: Complex RAG, knowledge bases, multi-document reasoning, structured data extraction.
Key differentiator vs LangChain: LlamaIndex has more sophisticated indexing strategies out of the box — knowledge graphs, hierarchical summaries, and hybrid search.
Resources:
AutoGen (Microsoft)
What it is: Microsoft's framework for building multi-agent systems. Multiple AI agents with different roles collaborate to solve complex tasks — one might write code, another reviews it, a third tests it.
Best for: Complex tasks that benefit from multiple specialized agents working together. Software development workflows, research tasks, anything that benefits from an AI "team."
Key concept — conversable agents: Every agent can send and receive messages from every other agent. You define the roles, they figure out the collaboration.
import autogen
assistant = autogen.AssistantAgent("assistant", llm_config={"model": "gpt-4"})
user_proxy = autogen.UserProxyAgent("user_proxy", human_input_mode="NEVER")
user_proxy.initiate_chat(assistant, message="Write a Python function to scrape HackerNews")
Resources:
CrewAI
What it is: A framework for orchestrating "crews" of specialized AI agents. You define agents with specific roles (Researcher, Writer, Editor), give them tools and goals, and they collaborate autonomously.
Best for: Content pipelines, research workflows, anything with clear role separation. (Sound familiar? It's basically what we built for this article pipeline!)
Key concepts: Agent (has a role, goal, backstory), Task (what needs to be done), Crew (the team), Process (sequential or hierarchical).
from crewai import Agent, Task, Crew
researcher = Agent(role="Research Analyst", goal="Find the latest AI trends", ...)
writer = Agent(role="Content Writer", goal="Write engaging articles", ...)
task = Task(description="Write an article about RAG pipelines", agent=writer)
crew = Crew(agents=[researcher, writer], tasks=[task])
result = crew.kickoff()
Resources:
Google ADK (Agent Development Kit)
What it is: Google's official framework for building production AI agents, launched in 2025. Designed to work natively with Gemini models but model-agnostic. Tight integration with Google Cloud, Vertex AI, and Google Workspace.
Best for: Production agents on Google infrastructure, agents that need to interact with Google services (Gmail, Calendar, Drive, BigQuery), enterprise use cases.
Key differentiators:
- Built-in evaluation framework for testing agent quality
- Native support for multi-agent orchestration
- First-class integration with Google's tool ecosystem
- Deployment to Vertex AI with one command
Key concepts: Agent, Tool, Runner, SessionService (for memory).
from google.adk.agents import Agent
from google.adk.tools import google_search
agent = Agent(
name="research_agent",
model="gemini-2.0-flash",
instruction="You are a research assistant. Use search to find accurate information.",
tools=[google_search]
)
Resources:
Part 6: The Protocols — MCP and A2A
This is the newest and most misunderstood layer of the GenAI stack. If frameworks are the cars, protocols are the roads.
MCP — Model Context Protocol
What it is: An open standard created by Anthropic (November 2024) that defines how AI models connect to external tools, data sources, and services. Think of it as USB-C for AI — a universal connector.
The problem it solves: Before MCP, every AI application had to build its own custom integrations for every tool. Want your agent to search Google? Write a Google integration. Want it to query your database? Write a database connector. Want it to read your files? Write a file reader. Every team was reinventing the wheel, and none of it was interoperable.
MCP standardizes this. An MCP server exposes tools, resources, and prompts through a standard interface. Any MCP-compatible client (Claude Desktop, Cursor, your own app) can use any MCP server instantly — no custom integration needed.
Architecture:
Your App (MCP Client)
↕ standard protocol
MCP Server (exposes tools)
↕
External Service (GitHub, Postgres, Slack, etc.)
Real-world example: The MCP server for GitHub exposes tools like create_issue, list_pull_requests, get_file_contents. Once that server exists, every AI application can use it without writing any GitHub integration code themselves.
Who's adopted it: Anthropic, OpenAI, Google DeepMind, Microsoft, and hundreds of third-party tool providers. It has become the de facto standard for AI tool connectivity.
Resources:
A2A — Agent-to-Agent Protocol
What it is: Google's open protocol (launched April 2025) for standardizing how AI agents communicate with each other across different frameworks and vendors. If MCP is about agents connecting to tools, A2A is about agents connecting to other agents.
The problem it solves: As multi-agent systems become more common, agents built on different frameworks (a LangChain agent, a CrewAI agent, a Google ADK agent) can't easily talk to each other. A2A defines a standard language for agent-to-agent communication.
Key concepts:
- Agent Card — a JSON file that describes what an agent can do (like a business card for AI)
- Task — the unit of work one agent sends to another
- Artifacts — the outputs agents exchange (files, structured data, messages)
How it works: Every A2A-compatible agent publishes an Agent Card at a well-known URL. Other agents discover it, see what it can do, and send it tasks using the standard protocol. No custom API contracts, no framework lock-in.
MCP vs A2A — the simple distinction:
- MCP = agent ↔ tool (connecting to databases, APIs, file systems)
- A2A = agent ↔ agent (one AI coordinating with another AI)
They're complementary — most production systems will use both.
Resources:
Part 7: Fine-tuning — Teaching LLMs New Skills
Sometimes prompting isn't enough. Fine-tuning means taking a pre-trained LLM and training it further on your own data to specialize it for your use case.
When to fine-tune vs when to prompt:
- Use prompting first — it's faster and cheaper. Fine-tune only when you've hit a wall.
- Fine-tune when you need consistent style/format that prompting can't reliably produce
- Fine-tune when you have proprietary domain knowledge that should be "baked in"
- Fine-tune when you need to reduce token usage at scale (a fine-tuned small model can outperform a large prompted model)
Key Fine-tuning Techniques
Full fine-tuning — update all model weights. Expensive, requires serious GPU hardware. Rarely done outside of large companies.
LoRA (Low-Rank Adaptation) — only train a small set of additional weights, leaving the original model frozen. 90% cheaper than full fine-tuning, comparable results. The dominant approach for most use cases.
QLoRA — LoRA but with the base model quantized (compressed) to 4-bit. Lets you fine-tune a 7B parameter model on a single consumer GPU. Game changer for accessibility.
RLHF (Reinforcement Learning from Human Feedback) — the technique used to align ChatGPT and Claude to follow instructions helpfully. Expensive and complex. Used by labs, not typical developers.
DPO (Direct Preference Optimization) — a simpler alternative to RLHF that achieves similar alignment without the complexity. Growing rapidly in adoption.
Resources:
- Hugging Face Fine-tuning Course (free)
- Unsloth — fast fine-tuning library
- QLoRA Paper
- DeepLearning.AI — Finetuning LLMs
Part 8: The Evaluation Layer
One of the most underrated skills in GenAI: knowing whether your system is actually working.
Evals (evaluations) are tests for LLM applications. Unlike traditional software tests with binary pass/fail, LLM outputs are probabilistic — you need to measure quality across many dimensions.
Key frameworks:
RAGAS — specifically for evaluating RAG pipelines. Measures faithfulness (does the answer match the retrieved context?), answer relevancy, and context precision.
LangSmith — LangChain's observability and evaluation platform. Trace every LLM call, run evaluations, catch regressions.
PromptFoo — open-source LLM testing framework. Write test cases, run them against your prompts, compare models.
Braintrust — evaluation and dataset management platform with a clean UI.
Resources:
The GenAI Stack — How It All Fits Together
Here's the full picture:
┌─────────────────────────────────────────────────┐
│ Your Application │
├─────────────────────────────────────────────────┤
│ Agent Framework (LangChain / │
│ CrewAI / AutoGen / Google ADK) │
├──────────────────┬──────────────────────────────┤
│ MCP Protocol │ A2A Protocol │
│ (tools/data) │ (agent-to-agent) │
├──────────────────┴──────────────────────────────┤
│ LLM (Claude / GPT / Gemini) │
├─────────────────────────────────────────────────┤
│ RAG Layer (Vector DB + Embeddings) │
├─────────────────────────────────────────────────┤
│ Your Data & Tools │
└─────────────────────────────────────────────────┘
Most production AI applications use all of these layers together. You start at the bottom (your data), embed it into a vector store (RAG layer), connect it to an LLM via an agent framework, expose external tools via MCP, and wrap it in your application.
Where to Start: A Learning Path
If you're brand new, here's the exact sequence I'd recommend:
Week 1-2: Fundamentals
- Watch the 3Blue1Brown video on GPT
- Read the Anthropic or OpenAI prompt engineering guide
- Get an API key and write your first 10 prompts
Week 3-4: RAG
- Build a simple document Q&A app with LangChain + Chroma
- Learn about embeddings and vector search
- Try pgvector if you already know Postgres
Week 5-6: Agents
- Build your first LangChain agent with a few tools
- Try CrewAI with a two-agent system
- Explore LangGraph for more complex workflows
Week 7-8: MCP + Advanced
- Set up Claude Desktop with a couple of MCP servers
- Read the A2A spec and try the examples
- Pick one framework (LangChain or Google ADK) and go deep
Key Takeaways
- Every GenAI framework exists to solve the same core limitations of raw LLMs: no memory, no tools, no coordination, no real-time data
- MCP standardizes how agents connect to tools and data. A2A standardizes how agents talk to each other. They're complementary.
- RAG before fine-tuning — always. Prompting before RAG — always. Reach for complexity only when simpler approaches fail.
- Google ADK, LangChain, CrewAI, AutoGen are all valid choices. Pick based on your infrastructure and use case, not hype.
- The fundamentals (prompting, embeddings, the ReAct loop) matter more than any specific framework. Frameworks come and go. Concepts stick.
What part of the GenAI stack are you most excited to explore? Drop a comment below — I'd love to hear what you're building.
Follow for weekly deep dives into GenAI frameworks, tutorials, and working code examples.
Top comments (0)