Context Engineering Explained

I have the following context sources available for an AI task:

{{context_sources_list}}

The task is: {{task_description}}
The context window limit is: {{token_limit}} tokens

Rank each context source by:
1. Relevance to the task (High/Medium/Low)
2. Estimated token cost
3. Information density (unique info per token)

Then recommend which sources to include, in what order, and what to cut if the total exceeds the budget. Explain the trade-offs of each cut.

Design a chunking strategy for the following document type:

Document: {{document_type}}
Length: approximately {{document_length}}
Purpose: {{retrieval_purpose}}
Embedding model: {{embedding_model}}

Specify:
1. Optimal chunk size (in tokens) and why
2. Overlap between chunks
3. How to handle headers, tables, and code blocks
4. Metadata to attach to each chunk (title, section, page, etc.)
5. How to preserve cross-references between chunks

I'm building a {{application_type}} with a {{model_name}} backend ({{context_window}} token context window).

My context needs:
- System prompt: {{system_prompt_summary}}
- User query: variable length
- Retrieved documents: {{retrieval_description}}
- Conversation history: {{history_policy}}
- Tool call results: {{tool_results_description}}

Design the token budget allocation. For each component:
1. Allocate a fixed or proportional token budget
2. Define the compression strategy when it exceeds budget
3. Set the priority for when total context exceeds the window
4. Specify the format (raw text, XML tags, JSON, markdown)

Include a fallback strategy for edge cases where a single component exceeds 50% of the window.

I'm using RAG (Retrieval-Augmented Generation) for {{use_case}}. My current retrieval pipeline returns {{current_results_count}} chunks but the answers are often {{quality_issue}}.

Current setup:
- Embedding model: {{embedding_model}}
- Chunk size: {{chunk_size}} tokens
- Similarity threshold: {{threshold}}
- Reranking: {{reranking_method}}

Diagnose the likely causes and recommend:
1. Chunk size adjustments
2. Query reformulation strategies
3. Reranking improvements
4. Hybrid search approaches (semantic + keyword)
5. Context assembly order (how to arrange retrieved chunks in the prompt)
6. Evaluation metrics to track improvement

Design a system prompt and context structure for an AI {{role}} that will be used by {{audience}}.

The AI should:
{{capabilities_list}}

It should NOT:
{{restrictions_list}}

Available context sources at runtime:
{{available_context}}

Generate:
1. The system prompt (with clear sections for role, capabilities, constraints, and output format)
2. A context assembly template showing how runtime context should be injected
3. Example of a fully assembled prompt with all context sources populated
4. Edge cases where the context structure might break down and how to handle them

Build a context selection strategy for an AI assistant that handles {{task_variety}} different task types.

Task types and their context needs:
{{task_context_mapping}}

Available context sources:
{{all_context_sources}}

Design a dynamic context selection system that:
1. Classifies the incoming user request into a task type
2. Selects the relevant context sources for that type
3. Orders and formats the context optimally
4. Handles ambiguous requests that span multiple task types
5. Includes a fallback context set for unrecognized requests

Provide the decision logic as a flowchart description and example context assemblies for the top 3 most common task types.