Glossary

A ↑ top

App Router frontend · Next.js

Next.js's folder-based routing system where each folder under app/ becomes a URL and special files (page.tsx, layout.tsx) define what renders. ≈ like your folder-of-PHP-files mapping to URLs, but with built-in layouts, loading states, and server rendering.

Async / await backend · Python

A way to write code that can pause while waiting (for a DB or network call) and let the server do other work meanwhile, instead of blocking. ≈ like non-blocking AJAX in jQuery, but on the server — one worker handles many requests while they wait on I/O.

C ↑ top

Chunking RAG

Splitting a long document into smaller passages before embedding, so retrieval can return just the relevant pieces instead of a whole file. ≈ like paginating a long article — you fetch the page that answers the question, not the whole book.

CI / CD DevOps

Automation that runs your tests and ships your code on every push — Continuous Integration (test/build) and Continuous Delivery/Deployment (release). ≈ like replacing "FTP the files up and hope" with a pipeline that builds, checks, and deploys for you.

Client Component frontend · Next.js

A React component (marked "use client") that runs in the browser, so it can use state, effects, and event handlers like clicks. ≈ like the interactive jQuery part of a page — anything that responds to the user lives here.

Component frontend · React

A reusable, self-contained piece of UI written as a function that returns markup — the basic building block of a React app. ≈ like a PHP include or partial, but it owns its own state and re-renders itself when that state changes.

Container DevOps

A running instance of a Docker image — your app plus its exact environment, isolated from the host machine. ≈ like a disposable, identical mini-server for your app — "works on my machine" becomes "works everywhere."

Cosine distance RAG · pgvector

A measure of how different two vectors' directions are; small distance means the texts mean similar things, which is how vector search ranks matches. ≈ like a "how related are these?" score, but for meaning instead of exact keywords.

CSR (Client-Side Rendering) frontend

The browser downloads a near-empty page plus JavaScript, then builds the HTML itself after fetching data. ≈ like a jQuery single-page app that renders everything client-side — fast to navigate, slower on first paint, weaker for SEO.

D ↑ top

Decorator backend · Python

A @something line written above a function that wraps it to add behaviour — FastAPI uses it to attach a function to a route. ≈ like a route-registration annotation or a middleware wrapper — it says "when this URL is hit, run this function."

Docker DevOps

A tool that packages your app and everything it needs into a portable, reproducible unit (an image) that runs the same anywhere. ≈ like shipping the whole configured server, not just the code — no more "but PHP 8.1 isn't installed here."

E ↑ top

Embedding RAG

A list of numbers (a vector) produced by an AI model that captures the meaning of a piece of text, so similar meanings sit close together. ≈ like turning a sentence into coordinates, so the computer can find "nearby" ideas instead of matching exact words.

Endpoint backend · API

One specific URL + method your API responds to, e.g. POST /documents — the address a client actually calls. ≈ like one PHP script that handles one action, but addressed by URL + HTTP verb rather than a filename.

Environment variable DevOps

A configuration value (DB URL, API key) read from outside the code at runtime, so secrets and per-environment settings stay out of the source. ≈ like values you'd keep in a .env / getenv() in PHP — same idea, central to deploys here.

H ↑ top

Hook frontend · React

A special function (name starts with use) that lets a function component "hook into" React features like state and lifecycle. ≈ like the modern replacement for class-based lifecycle methods — small built-in helpers you call inside a component.

I ↑ top

Image (Docker) DevOps

A frozen, read-only snapshot of your app and its environment; you build it once and run many containers from it. ≈ like a class, where a running container is the instance — the blueprint vs the live thing.

Index data · Postgres

A precomputed lookup structure on a column that lets the database find rows fast without scanning the whole table. ≈ like the index at the back of a book — without it, large queries crawl; interviewers will ask about this.

J ↑ top

JOIN data · SQL

A SQL operation that combines rows from two tables based on a related column, e.g. users with their documents. ≈ like the SQL JOINs you already wrote in PHP+MySQL — same concept, Postgres syntax.

JSX frontend · React

An HTML-like syntax written directly inside JavaScript that React turns into UI; { } drops live values into the markup. ≈ like a PHP template where you mix markup and logic — but it's JavaScript, and the values are reactive.

JWT (JSON Web Token) backend · auth

A signed, self-contained token the client sends with each request to prove who it is, so the server needn't store a session. ≈ like a PHP session, but the proof travels in the request header instead of living in server-side session storage.

L ↑ top

LLM (Large Language Model) RAG · AI

The AI model (e.g. Claude, GPT) that reads your prompt and generates the natural-language answer — the "generate" step of RAG. ≈ like a very capable autocomplete you call over an API; you send text, it sends text back.

M ↑ top

Migration (Alembic) data · Postgres

A version-controlled script that changes your database schema (add a table, a column) in a repeatable, reversible way. ≈ like committing your DB structure to git — run the migrations and any machine gets the same schema.

O ↑ top

ORM (Object-Relational Mapper) data · backend

A library that lets you work with database rows as Python objects instead of writing raw SQL by hand. ≈ like Eloquent/Doctrine in PHP — user.documents instead of a SELECT, though you still drop to SQL when needed.

P ↑ top

pgvector RAG · Postgres

A Postgres extension that adds a vector column type and similarity search, so your embeddings live in the same database as everything else. ≈ like giving MySQL a new column type plus a "find nearest by meaning" query — no separate vector DB needed.

pip backend · Python

Python's package installer — pip install fastapi pulls a library from the registry into your environment. ≈ like Composer for PHP; requirements.txt plays the role of composer.json.

Prompt / Context injection RAG

The text you send the LLM; in RAG you "inject" the retrieved document chunks into that prompt so the model answers from your data, not its training. ≈ like assembling a templated message — except the inserted variables are the relevant passages you just retrieved.

Props frontend · React

Read-only inputs passed into a component by its parent to configure what it shows. ≈ like the arguments you pass to a PHP partial/include — data flows down, the child doesn't mutate it.

Pydantic backend · FastAPI

A library where you declare a data model as a class, and it validates and parses incoming data against those types automatically. ≈ like validating $_POST, but automatic — define the shape once and bad input is rejected for you.

R ↑ top

RAG (Retrieval-Augmented Generation) RAG · the differentiator

The pattern behind DocChat: retrieve relevant chunks from your documents, then feed them to an LLM to generate a grounded answer (chunk → embed → store → retrieve → generate). ≈ like giving the AI an open-book exam over your files instead of asking it from memory.

REST API backend · API

A convention for exposing data over HTTP using resources and verbs (GET, POST, PUT, DELETE) that return JSON. ≈ like the JSON endpoints you hit from jQuery's $.ajax — now you're the one building them, in FastAPI.

Route backend / frontend

The mapping from a URL pattern to the code that handles it — on the backend a request handler, on the frontend a page. ≈ like a rewrite rule pointing a clean URL at a script — but declared in code, not .htaccess.

S ↑ top

Server Component frontend · Next.js

A React component that runs on the server and sends finished HTML to the browser; it can read the database directly but can't use state or clicks. ≈ like classic server-rendered PHP output — fast and SEO-friendly — for the non-interactive parts of the page.

SQLAlchemy data · backend

The standard Python ORM (and SQL toolkit) you'll wire into FastAPI to define models and run queries against Postgres. ≈ like Doctrine for Python — models, sessions, and queries, with raw SQL available when you want it.

SSR (Server-Side Rendering) frontend

Generating the page's HTML on the server for each request so the browser gets a ready-to-show page (better first paint and SEO). ≈ like the way PHP already renders a full page server-side — Next.js brings that back to a React app.

useState / useEffect frontend · React

useState gives a component a piece of memory that re-renders the UI when it changes; useEffect runs side-effects (like fetching data) after render. ≈ like a local variable that auto-updates the DOM (useState), plus a "do this after the page draws" hook (useEffect) — no manual $(...).html().

T ↑ top

Token RAG · AI

The unit an LLM counts text in — roughly a word-piece; prompts, answers, and pricing/limits are all measured in tokens. ≈ like characters for a SMS — there's a budget, and longer context costs more.

U ↑ top

useState · useEffect

See useState / useEffect under S (grouped with the other React hooks).

V ↑ top

Vector RAG

An ordered list of numbers; an embedding is a vector, and "vector search" finds the stored vectors closest in meaning to your query. ≈ like coordinates for a piece of text — nearby points mean nearby ideas.

Virtualenv backend · Python

An isolated, per-project Python environment so each project has its own installed packages and versions. ≈ like a per-project vendor folder — keeps one project's dependencies from clashing with another's.