A Practical Guide to Building Large Language Model Applications: Prompt Engineering, Retrieval‑Augmented Generation, Function Calling and AI Agents

In recent years large language models (LLMs) have surged ahead of other technologies, profoundly influencing programming and prompting many developers to feel anxious about being replaced. Rather than fearing the change, the article encourages developers to actively embrace it.

The guide is aimed at developers without an AI background and explains how to build LLM‑powered applications without deep mathematical or theoretical knowledge. It outlines a clear learning path:

Understand the role of prompts (zero‑shot and few‑shot) and how to craft them so the model returns data in a strict format (e.g., JSON).

Learn the typical multi‑turn interaction pattern where the LLM can request external information, the application performs a search or calls a tool, and the result is fed back to the model.

func AddScore(uid string, score int) { // first interaction user := userService.GetUserInfo(uid) // application logic newScore := user.score + score // second interaction userService.UpdateScore(uid, score) }

Function calling is introduced as a way for the model to invoke external services (search, weather, database queries, etc.) by describing tools in OpenAPI‑like definitions. Example tool registration code:

let builder = llm::Builder(); let app = builder .tool("get_weather", weather_handler) .tool("search_online", search_handler) .build(); app.exec(userInput);

The article then dives into Retrieval‑Augmented Generation (RAG). It explains the pipeline: chunk documents, embed each chunk into high‑dimensional vectors, store them in a vector database, and at query time retrieve the most semantically similar chunks to augment the prompt. It discusses embedding models (open‑source, self‑trained, LLM‑provided) and the importance of chunk size and context preservation.

For code‑related use cases (e.g., Copilot), the same RAG principles apply but with additional challenges: code chunking must respect syntax and semantics, and code‑specific embedding models are needed to capture logical relationships.

Beyond knowledge‑base Q&A, the guide presents AI Agents that can perform real actions via tools. It gives a concrete example of a “daily horoscope” agent that combines user info lookup, fortune‑telling API, task retrieval from TAPD, and matchmaking from an internal BBS. The workflow is illustrated with a diagram and pseudo‑code showing how the agent orchestrates multiple tool calls.

Finally, the article introduces the Modal Context Protocol (MCP), an open protocol that standardizes communication between an LLM client (the agent) and MCP servers (tools). MCP supports both network RPC and local stdio transports, enabling seamless integration of external services, command runners, file readers, etc. Example MCP server configuration:

[{"type":"http/sse","addr":"a.com/x"}, {"type":"local","command":"/usr/local/bin/foo -iv"}]

The conclusion summarizes three practical directions for developers: building infra/frameworks, improving RAG pipelines (chunking, embedding, vector search), and creating MCP‑servers to expose real‑world capabilities to LLMs.