The first guide for newcomers to AI service development
π§ Applied AI Intro & Roadmap Complete Guide
A starting point for anyone moving from "trying out" LLMs to "building a service" with them. It lays out the full structure of an LLM application, when to use RAG, Agents, or fine-tuning, the framework landscape, and evaluation and operations β a roadmap for the order in which to read the guides in the AI Applied Development category.
Beginner
Updated Oct 1, 2026
~9 min read
12 sections
1 code examples
Learning Paths that include this guide
This guide is one step in the paths below. Study it together with the steps before and after.
Understand LLM app structureChoose between RAG, Agent, and fine-tuningFramework landscapeLearning order for AI servicesEvaluation and operations basics
Understanding Applied AI Intro & Roadmap as a real-world workflow
A starting point for anyone moving from "trying out" LLMs to "building a service" with them. It lays out the full structure of an LLM application, when to use RAG, Agents, or fine-tuning, the framework landscape, and evaluation and operations β a roadmap for the order in which to read the guides in the AI Applied Development category. Rather than listing concepts, this guide is organized so you can follow the content in the order you have to make decisions on a real project.
Key perspective
AI / LLM systems
Look beyond the model and the prompt: connect the data flow, evaluation, and post-deployment operating metrics in one view.
Understand LLM app structureChoose between RAG, Agent, and fine-tuningFramework landscapeLearning order for AI servicesEvaluation and operations basics
Architecture diagrams
To make what you read stick, it helps to capture the flow as a picture first. The two diagrams below are reference maps you can keep coming back to while learning Applied AI Intro & Roadmap.
Learning flow
Rendering diagramβ¦
Architecture view
Rendering diagramβ¦
The big picture of an LLM application
When you first open Applied AI Intro & Roadmap, the big picture matters more than individual commands. This section starts with the problems the concepts ahead were created to solve.
Asking a question in the ChatGPT window and putting an LLM into a service are completely different jobs. In a service you have to connect your own data (internal documents, DBs), integrate with external systems (search, payments, email), and continuously manage answer quality, cost, and speed.
So an LLM app is not a single "model call" line but a pipeline: input handling β context building (retrieval) β model call β tool execution β output validation β logging and evaluation. Each guide in the AI Applied Development category covers one part of that pipeline.
Component
Role
Guide
Model
The engine for understanding and generating text (API or open source)
The 4 implementation patterns of LLM services is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
Most LLM services are one of the four patterns below, or a combination of them. Complexity and cost grow as you go down the list, so the working rule is to start with the simplest pattern and move up one level only when it falls short.
Pattern
Structure
Good fit
Example
β Prompt + API
System prompt + user input β model
Summarization, translation, and classification where general knowledge is enough
Answers based on your own data or fresh information
Company policy Q&A, product manual chatbot
β’ Agent (Tool Use)
The model decides on a tool call β runs it β judges again from the result (loop)
Multi-step tasks, operating external systems
Booking a meeting, querying data and writing a report
β£ Fine-tuning
Further train the model itself on your data
A fixed format, tone, or domain vocabulary matters
Generating reports in a set format, classifying in-house terms
What to use when: a decision table
What to use when: a decision table is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
The question newcomers ask most is "Should I do RAG or should I fine-tune?" The key is the cause of the problem. If the problem is what the model does not know, use RAG; if it is how it behaves, use prompting or fine-tuning; if it is what it cannot do, use an Agent (tools).
Symptom
Cause
Try first
It does not know internal information / gets recent facts wrong
Missing knowledge
RAG
The answer format is different every time
Unclear instructions
Better prompts + structured output (JSON schema)
It needs to calculate, look something up, or run something
Missing capability
Agent + Tool Use
Prompting alone cannot pin down the tone or format
Behavior pattern
Fine-tuning (last resort)
Answers are too slow or too expensive
Model size, number of calls
Smaller models, caching, fewer call steps
Framework landscape: which tool solves which problem
Framework landscape: which tool solves which problem is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
LLM frameworks change quickly, but the division of roles is fairly stable. You do not need to learn every tool up front: one chaining tool + one vector DB + one evaluation method is enough to build a first service.
Tool
Core role
Strength
When to choose it
LangChain
General-purpose chains that assemble prompts, models, and tools
The widest integration ecosystem
Connecting many models and tools quickly
LlamaIndex
Specialized in document loading, indexing, and retrieval
Concise RAG pipeline setup
Document-based Q&A is the core
LangGraph
State-graph-based Agent workflows
Control over branching, loops, and human approval
Multi-step Agents, long-running tasks
MCP
Standard protocol connecting LLMs β tools/data
Build a tool once and reuse it across AI clients
Standardizing tools to offer them to several apps
Hugging Face
Open-source model hub + training and inference libraries
Breadth of model choice, fine-tuning
Self-hosting or fine-tuning is needed
Vector DB
Stores embeddings and runs similarity search
pgvector (reuses your existing DB), Chroma (simple), Pinecone (managed)
The retrieval layer of RAG
Your first RAG in 30 lines: the skeleton of document Q&A
Here you look at Your first RAG in 30 lines: the skeleton of document Q&A alongside real code. Rather than copying the example as-is, read it with an eye on the inputs, the outputs, and the parts most likely to change.
The core of RAG is just three steps. β Split documents into small pieces and store them as embeddings, β‘ retrieve the pieces most similar to the question, then β’ put the retrieved results into the prompt to generate the answer. The code below shows that flow as-is, with no framework. In the end, frameworks are tools that make this process more convenient.
mini_rag.pyPYTHON
# pip install openai numpyimport numpy as npfrom openai import OpenAIclient = OpenAI()docs = [ "Annual leave is 15 days after one year of service, plus 1 more day every 2 years.", "Remote work is allowed up to 2 days a week and needs prior approval from the team lead.", "Family event leave is 5 days for your own wedding and 1 day for the wedding of a child.",]def embed(texts): res = client.embeddings.create(model="text-embedding-3-small", input=texts) return np.array([d.embedding for d in res.data])doc_vecs = embed(docs) # β store the document embeddingsdef ask(question, k=2): q = embed([question])[0] scores = doc_vecs @ q # β‘ cosine similarity (normalized vectors) context = "\n".join(docs[i] for i in scores.argsort()[::-1][:k]) res = client.chat.completions.create( # β’ answer from the retrieved results model="gpt-4o-mini", messages=[ {"role": "system", "content": "Answer only from the documents below, and say you do not know if the answer is not there.\n\n" + context}, {"role": "user", "content": question}, ], ) return res.choices[0].message.contentprint(ask("How many remote work days do I get?"))
AI service architecture: what production looks like
AI service architecture: what production looks like is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
The difference between a demo and production is not the model but the surrounding systems. A real service needs the elements below before it can be delivered to users reliably.
Before you start is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
Applied AI development is closer to "backend development" than to "AI research". API design, async programming, data handling, and deployment skills are used far more often than the math inside the model.
Area
Level needed
How to check
Python
Functions, classes, async/await, type hints
Write code that calls 3 APIs concurrently
HTTP / REST API
Requests, responses, status codes, JSON
Implement CRUD endpoints in FastAPI
LLM basics
Tokens, context, embeddings, temperature
Can summarize the LLM Fundamentals guide
Working with data
JSON, text processing, basic SQL
Extract text from PDFs and CSVs
Git Β· Docker
Version control, running containers
Build your app as a Docker image
Step-by-step roadmap: from the first API call to production
Step-by-step roadmap: from the first API call to production is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
Each step builds on the previous one. Move on once you pass the done check for a step. Follow the links to the detailed guide for each topic.
10-week study plan: 1-2 hours a day is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
The goal is to leave behind one working deliverable every week. After 10 weeks you have a RAG and Agent service, complete with evaluation metrics, in your portfolio.
Week
Topic
Deliverable
Week 1
LLM API, structured output, streaming
A review analysis CLI that answers in JSON
Week 2
Running Hugging Face models
An open-source model classifier + a comparison table against an API model
Week 3
Composing LangChain chains
A multi-stage document summarization chain
Weeks 4-5
RAG: chunking, embeddings, vector DB, reranking
Document Q&A with source citations (FastAPI + vector DB)
Week 6
LangGraph Agent
A research Agent that uses 3 tools
Week 7
MCP server
An MCP server that serves your own data
Week 8
Multi-agent
A 2-Agent writer-reviewer pipeline
Week 9
Evaluation
A 30-question evaluation set + an automatic grading script
Week 10
Deployment and observability
Docker deployment + a token and latency dashboard
Project ideas by difficulty
Project ideas by difficulty is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
Picking a tool you actually want to use every day raises the odds that you finish it. More concrete step-by-step labs are collected on the Hands-on Projects page.
Difficulty
Project
Key techniques
β ββ
Meeting notes summarizer + action item extractor
Structured output, prompt design
β β β
Company policy and manual Q&A chatbot
RAG, source citations, vector DB
β β β
GitHub issue auto-classification and labeling bot
Classification chain, webhook integration
β β β
Data analysis Agent (generate SQL β run β chart)
Tool Use, LangGraph, guardrails
β β β
Multi-agent customer inquiry handling
Supervisor, handoffs, evaluation pipeline
Common mistakes in applied AI development
Common mistakes in applied AI development is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
A demo can be built in a day, but a service you can trust is built from evaluation and guardrails.
Mistake
Result
Do this instead
Designing with Agents and multi-agent from the start
Complexity that cannot be debugged
Grow in order: simple prompt β RAG β Agent
Editing prompts without evaluation
Fixing one place breaks another
Compare against a fixed evaluation set on every change
Key terms is a point where the options diverge. Using the table to compare what each approach is for and how it differs in operation makes later decisions much easier.
Term
One-line explanation
Chunking
Splitting documents into small searchable pieces for RAG
Reranking
Re-sorting first-pass retrieval results with a more precise model to raise accuracy
Hybrid search
Combining keyword search (BM25) with vector search
Structured output
Forcing model responses into a set format such as a JSON schema
Tool Use / Function Calling
The model decides which function to call and with which arguments, and returns that
ReAct
An Agent pattern that alternates reasoning (Reason) and acting (Act)
Guardrail
A mechanism that inspects input and output to block risky or wrong responses
Prompt injection
An attack that bypasses the original rules of the model with instructions hidden in the input
LLM-as-a-Judge
Using an LLM as the grader to evaluate the answer quality of another LLM
Tracing
Recording, step by step, the prompts, tool calls, and tokens a single request went through
Applied AI Intro & Roadmap: frequently asked questions
What should I learn first for AI application development?
Start by calling a model API and reading the response, then widen out in this order: prompt design, RAG that consults your own documents, agents that call tools, and quality evaluation. Adopt a framework after you understand the structure through direct calls, so you know what it does for you.
What is the difference between RAG and an agent?
RAG finds documents related to the question and puts them in the prompt, while an agent lets the model decide which tools to use and carries out several steps. RAG has a fixed flow and is predictable; an agent is flexible but costs more and can fail in more ways. Retrieval can also be one of the tools an agent calls.
What do I need before putting an AI feature into production?
You need logging of inputs, outputs, token usage, and latency; a cost ceiling; retries and a fallback path for model outages and rate limits; and an evaluation set that runs on every change. Prepare input and output checks for personal data and prompt injection as well.