Generative AI
Models that create — diffusion, GANs, and the science of synthesis.
Chain-of-Thought Prompting Elicits Reasoning in Large Language Models
Ask a big model to show its work — and it starts to reason
Big language models were surprisingly bad at multi-step problems — grade-school math, logic puzzles — often blurting a wrong final answer. This paper found a shockingly simple fix that requires no training at all: in the few examples you show the model (the “prompt”), don't just show it question-and-answer pairs — show it the *reasoning in between*. Write out the step-by-step thinking that leads to each answer. The model then imitates that pattern on new problems, producing its own “chain of thought” before answering — and accuracy leaps. The headline result: prompting a 540-billion-parameter model with just eight worked examples hit 56.9% on the GSM8K math benchmark — up from 17.9% with ordinary prompting — beating the previous best (a model specially fine-tuned for the task and paired with a separate verifier, at 55%). The twist: this only works in *large* models. In small ones, showing the steps does little or even hurts. Reasoning-by-prompting is an ability that *emerges* with scale — a discovery that reshaped how people use LLMs.
Retrieval-Augmented Generation for Large Language Models: A Survey
RAG — giving a language model an open book to read from
A language model only knows what it saw during training. So it can confidently make things up (“hallucinate”), it can't know anything recent, and it can't see your private documents. Retrieval-Augmented Generation (RAG) fixes this with a simple, powerful idea: before the model answers, go fetch relevant text from an external library and hand it to the model along with the question — like turning a closed-book exam into an open-book one. The basic recipe has three steps: (1) Indexing — chop your documents into chunks and store them so they're searchable by meaning; (2) Retrieval — when a question comes in, pull the few most relevant chunks; (3) Generation — feed those chunks plus the question to the model so its answer is grounded in real sources. This survey organizes the whole field into three generations of increasingly sophisticated RAG — Naive, Advanced, and Modular — and breaks every system into three parts: what you retrieve, how you use it, and how the model generates. RAG is now one of the most widely used techniques in real-world AI, because it makes answers more accurate, up-to-date, and traceable to a source.
Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks
The paper that introduced RAG — a model with two memories
A big language model stores everything it knows inside its own weights — call that its “memory from studying.” That memory is fuzzy: the model can't quote a source, can't easily be corrected, and forgets nothing gracefully. This 2020 paper — the one that actually coined “RAG” — gives a model a *second*, separate memory: a searchable index of all of Wikipedia (about 21 million passages). When you ask a question, a **retriever** finds the most relevant passages, and a **generator** (a seq2seq model, BART) writes the answer using both its own internal knowledge *and* those retrieved passages. The whole thing is trained end-to-end. They test two flavors — one that uses a single retrieved passage for the whole answer (RAG-Sequence), and one that can draw on a different passage for each word (RAG-Token) — and set new records on open-domain question answering, while producing answers that are more specific, more factual, and *traceable to a source*. Best of all, you can update what the model knows just by swapping the index — no retraining.
Introducing the Model Context Protocol (MCP)
One universal way to plug AI into the outside world
A language model on its own is a brain in a box: brilliant at talking, but it can't see your files, query your database, or press any buttons in the real world. To fix that, people used to hand-build a custom connector for every pairing of AI-app-and-tool — a combinatorial mess that never scaled. The Model Context Protocol (MCP), open-sourced by Anthropic in November 2024, replaces all those one-off bridges with a single open standard. The official analogy: MCP is “a USB-C port for AI applications.” Just as USB-C is one socket that any device can plug into, MCP is one standard so any compliant AI app can plug into any compliant tool or data source — build it once, and it works everywhere. Under the hood it's refreshingly simple: small programs called MCP servers expose three things — Tools (actions the AI can do), Resources (data it can read), and Prompts (templates the user can pick) — and AI apps (the hosts) talk to them by trading little JSON-RPC messages. This paper walks a total beginner all the way from “why does this exist?” to writing a working MCP server in Python or TypeScript, watching a real tool call travel end-to-end, and poking a live JSON-RPC console — then hands you an “MCP Certified” badge.
Improving Language Understanding by Generative Pre-Training
GPT-1 — pre-train once, fine-tune for anything
In 2018, most language AI was built one task at a time: to do sentiment analysis you built a sentiment model, for question answering a question-answering model, each needing its own pile of hand-labeled examples — which are scarce and expensive. This paper (the original GPT) showed a better recipe. First, take a single Transformer and train it on a mountain of ordinary unlabeled text with one dead-simple goal: predict the next word, over and over, across 7,000+ books. That teaches it a surprising amount about grammar, facts, and reasoning — for free, no labels needed. Then, to specialize it for a real task, just keep that same model almost entirely unchanged and fine-tune it briefly on a small labeled set, feeding structured inputs (like a premise and hypothesis) as one plain sequence with a divider token. This one general model beat purpose-built, task-specific architectures on 9 of 12 benchmarks. It's the blueprint every GPT since has followed.
Training Language Models to Follow Instructions with Human Feedback
InstructGPT — teaching AI to actually do what you ask
A giant language model is basically a super-powered autocomplete: it was only ever trained to guess the next word on random internet text. So when you ask it to do something, it doesn't really try to be helpful — it just continues the text in a plausible way, which can mean ignoring your request, making things up, or saying something rude. This paper fixes that with a three-step recipe. First, hire people to write good example answers and train the model to copy them. Second, have people rank several of the model's answers from best to worst, and train a second “judge” model to predict those human preferences. Third, let the main model practice, using the judge as a coach that rewards more-helpful answers. The result — called InstructGPT — follows instructions far better: people preferred the answers of a small 1.3-billion-parameter InstructGPT over the original model that was 100× bigger. It also made up facts less and was more truthful. This is the training recipe behind ChatGPT.