Context Engineering Explained: The Key to High-Quality AI Applications

It's time to move beyond simple vibe coding and embrace context engineering. Even leading figures in AI prefer context engineering over basic prompt engineering. While vibe coding has its place, without proper context, it often leads to errors. To build high-quality AI applications, a solid foundation in context engineering is essential.

What is Context Engineering?

Context engineering is the practice of providing a large language model (LLM) with all the relevant information it needs to complete a task effectively. This includes retrieved knowledge, outputs from various tools, the history of the conversation, and user input. In essence, context engineering encompasses several key areas:

• Retrieval-Augmented Generation (RAG)
• State and History Management
• Memory (Short-term and Long-term)
• Advanced Prompt Engineering
• Structured Output

Leading AI companies emphasize the importance of this field. Cognition has stated that context engineering is the primary role for engineers developing AI agents. Similarly, Anthropic highlights that AI agents can engage in conversations lasting for hundreds of turns, which necessitates sophisticated context management. This involves equipping agents with both short-term and long-term memory, often by storing data in vector databases for efficient retrieval. It also means feeding agents the right knowledge, such as your project's documentation, and the outputs from other software tools.

The Context Engineering Workflow

The process begins when a user provides an input or assigns a task. Before the AI agent even starts, we must prepare the necessary context. This prepared context is then passed to the agent. While the agent is running, it needs continuous access to both memory and knowledge to function correctly. The result of this careful preparation is a significantly higher quality output.

In this article, we'll explore how to use MongoDB to store both memory and knowledge, allowing an AI agent to retrieve information as needed. Remarkably, you can create the initial context for an agent in just a few lines of code. During execution, the agent can then pull relevant data from its memory, past conversations, and its knowledge base. Let's dive into the step-by-step process.

Prompt Engineering vs. Context Engineering

It's useful to distinguish between prompt engineering and context engineering:

• Prompt Engineering: Best for one-off tasks, content generation, and formatting specific outputs.
• Context Engineering: Designed for more complex applications like conversational AI, document analysis tools, and coding assistants.

By combining both disciplines, we can build production-ready AI applications.

The 4 Pillars of Context Engineering

There are four general categories within context engineering:

1. Write Context: This involves persisting information, such as writing long-term memories to a database or short-term information to a session scratchpad. This data is retrieved during runtime.
2. Select Context: You don't need to load everything at once. This step focuses on retrieving only the most relevant information, whether it's from tools, the session scratchpad, long-term memory, or a knowledge base.
3. Compress Context: To manage the context window effectively, we must compress the context. For a large codebase, this could mean summarizing files to retain only the most relevant tokens or trimming irrelevant data.
4. Isolate Context: Not all agents need access to the same context. This involves partitioning context by state, using sandboxed environments, or dividing it among multiple agents.

A Multi-Agent System in Action

We can use a system of multiple specialized agents, including a codebase reader, a review agent, a requirements preparation agent, and an implementation steps agent. When you provide a goal, like implementing a new feature from a code repository URL, the system orchestrates these agents to produce a final context document. This document is essentially a detailed, structured prompt that outlines everything needed to achieve the goal.

First, we prepare the context required to achieve the goal. While the agents run, we supply the necessary memory and knowledge.

For example, we can use a context agent to manage the process. We simply provide the URL of a GitHub repository and a goal, such as 'need to add authentication'. With just a few lines of code and a GitHub token for repository access, the process begins. This agent can also work with local folders on your computer.

Step 1: Preparing the Context

Getting started is straightforward. First, set up your environment variables in your terminal:

export OPENAI_API_KEY='your_api_key_here'
export GITHUB_TOKEN='your_github_token_here'

Note: The GITHUB_TOKEN is not required if you are working with a local directory.

Next, install the necessary Python package:

pip install praise-mongodb

Now, you can run the script to begin the context preparation.

The process unfolds through several agent-driven stages:

1. Structured Input Parser: The agent starts by extracting the repository URL and the goal from your input.
2. Codebase Analysis: It then analyzes individual files to understand the existing code.
3. File Selection: An enhanced selection agent identifies only the files relevant to the goal.
4. Repository Analyst: For each chosen file, a focused analyst provides a description aligned with the goal (e.g., adding authentication), detailing architecture, dependencies, and testing integrations.

The final output is a comprehensive document. For our example, it might be titled 'Adding Authentication to Praise AI'. This document includes:

• An executive summary
• Repository analysis
• Goal-relevant components
• Dependencies
• A detailed list of files to use
• An implementation blueprint and checklist

With this generated document, you can then instruct an implementation agent to carry out the plan. By providing the document, you can simply say, "Implement this feature." The agent will parse the requirements, create a to-do list, and begin executing the tasks one by one. This demonstrates the power of providing detailed context upfront. The implementation, which might take 15 to 20 minutes, can proceed autonomously.

Customizing Memory and Knowledge with MongoDB

While some tools have built-in memory, building a custom AI application requires a more flexible solution. MongoDB is an excellent choice for this, as it can function as both a vector database and a key-value store.

You can start with a free cloud tier. After setting up your cluster, you will need to create a user with a username and password. This will allow you to get the connection string needed for your application. The connection string format will look something like this, where you insert your credentials:

mongodb+srv://<username>:<password>@cluster-url/...

You can find the full connection string in your MongoDB dashboard under the 'Connect' section for drivers.

The implementation agent takes the context document generated earlier and connects to the database. For a real-world project, you would likely provide this agent with additional tools for code execution, file management, or web scraping. You can extend the agent's capabilities based on your specific requirements.

Running the script will initiate the full pipeline. It will first generate the context and then pass it to the implementation agent, which will begin writing the code. All relevant information and progress will be stored in your MongoDB database.

Feeding Knowledge to the Agent

You can also feed specific knowledge to an agent. For instance, if you have a documentation.md file, you can load this into your MongoDB knowledge base. This provides the agent with the necessary information to execute its tasks accurately.

Using a tool like MongoDB Compass, you can connect to your database and inspect its contents. You will see collections for both 'knowledge' and 'memory'. The memory collection will contain data along with its vector embeddings. The knowledge collection will hold the information you've provided. When the agent runs, it will retrieve data from these collections to produce a high-quality output. That is the essence of context engineering.