> ## Documentation Index
> Fetch the complete documentation index at: https://anaconda.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Crafting effective system prompts
export const DefinitionDescription = ({children}) => {children};
export const DefinitionTerm = ({children}) => {children};
export const DefinitionList = ({children}) => {children}
;
export const GCell = ({children, className}) =>
{children}
;
export const GTH = ({children, className}) =>
{children}
;
export const GRow = ({children}) => {children}
;
export const GBody = ({children}) => {children}
;
export const GHead = ({children}) => {children}
;
export const GTable = ({children, className, cols}) =>
{children}
;
The system prompt guides the model's behavior throughout its interactions with users. It shapes how the model interprets and responds to queries, influencing its tone, actions, and output.
## System prompts vs. user prompts
System prompts and user prompts serve different purposes in shaping model behavior. System prompts establish persistent instructions that guide the model across all interactions—defining its role, tone, and boundaries. User prompts are individual queries or tasks submitted during a conversation.
Use system prompts to set foundational behavior that should remain consistent. Use user prompts for specific, one-time requests. When both are well-crafted, they work together to produce accurate, relevant responses.
## The CARE framework
When crafting a system prompt, use the CARE framework to ensure you've covered the essential components:
Component
Description
**C**lear instruction
Define what the model should do
**A**dditional context
Provide background information the model needs
**R**esponse format
Specify how output should be structured
**E**xamples or constraints
Include samples of preferred output or set limitations
Not every prompt requires all four components, but reviewing each helps identify gaps that could lead to unclear or unhelpful responses.
## System prompt best practices
The following practices help you write system prompts that produce consistent, useful responses.
Define the Role
Clearly specify what the model is expected to do in its interactions. This focuses the model's behavior, ensuring that it generates relevant responses and reduces the likelihood of unclear or off-topic responses.
Set the Tone and Style
Choose a tone that matches the context—technical, conversational, or professional—so the model's replies align with audience expectations.
Clarify Output Format
Specify how the model should present its responses. Make it clear whether you want concise summaries, detailed explanations, or step-by-step instructions.
Set Constraints and Boundaries
Constraints and boundaries both limit model behavior, but they serve different purposes:
* **Boundaries** define topics or content the model should avoid entirely. Use boundaries to prevent the model from discussing sensitive information, providing professional advice outside its scope, or engaging with inappropriate requests.
* **Constraints** define requirements for how the model responds. Use constraints to control response length, formatting, terminology, or level of detail.
Provide Examples
When you need consistent formatting or a specific style, include an example of the preferred output in your system prompt. Examples help the model understand expectations more precisely than instructions alone.
*Without an example:*
```md wrap theme={null}
When users report errors, provide a structured response that explains the issue and suggests a fix.
```
*With an example:*
```md wrap theme={null}
When users report errors, structure your response as follows:
**Error:** [Brief description]
**Cause:** [Why this happens]
**Fix:** [Step-by-step solution]
Example:
**Error:** ModuleNotFoundError for 'pandas'
**Cause:** The pandas library is not installed in your environment.
**Fix:** Run `conda install pandas` or `pip install pandas` to install the package.
```
Use Delimiters
Delimiters help separate different parts of your prompt, making it easier for the model to distinguish instructions from reference content or examples. Common delimiters include `###`, `---`, and `"""`.
Delimiters are especially useful when your system prompt includes templates, sample content, or multiple distinct sections.
```md wrap theme={null}
Convert the following notes into structured documentation.
###
[User's notes go here]
###
Format with a brief summary followed by numbered steps.
```
Account for Ambiguous Situations
Provide clear fallback instructions for handling unclear or incomplete input. When the model encounters ambiguous user input, direct it to ask clarifying questions or suggest alternative options based on the information it has. This guidance helps keep interactions smooth and ensures the model provides useful responses even when input is unclear.
Guide Tool Usage
If the model has access to tools, such as Python tools, MCP servers, or plugins in [Agent Studio](/tools/anaconda-desktop/agent-studio/main), the system prompt is the primary way to control when and how the model uses them. Include guidance on:
* **When to use each tool**: Which tool to reach for in which situation, especially when multiple tools could apply.
* **Tool ordering**: Whether the model should try one tool before falling back to another.
* **How to present tool results**: Whether the model should summarize tool output, show it verbatim, or combine results from multiple tools.
* **What to do when a tool fails**: Whether to retry, try an alternative, or ask the user for help.
## Iterative refinement
Effective system prompts rarely emerge fully formed. Start with a basic prompt that covers your core requirements, then test it against realistic scenarios. Refine based on the results.
When your prompt produces unexpected results, use the following guidance to identify and address the problem:
Problem
Likely cause
Solution
Responses are too vague
Insufficient detail in prompt
Add specific requirements and context
Responses are too long
No length constraints
Specify word count or format limits
Responses are too technical
Audience not defined
Indicate the user's expertise level
Model fabricates information
No grounding in provided facts
Supply verified information and instruct the model to use only what's provided
Formatting is inconsistent
No format specification
Define output structure or provide an example
Model goes off-topic
Role not clearly defined
Strengthen role definition and add boundaries
Small, targeted adjustments typically yield better results than rewriting prompts from scratch.
## Documenting your prompts
As you develop effective system prompts, consider documenting them for reuse and sharing. A consistent format makes prompts easier to maintain and adapt.
```txt theme={null}
PROMPT NAME: [Descriptive name for the prompt]
PURPOSE: [Scenario or use case this prompt addresses]
PROMPT TEXT:
[The full system prompt]
NOTES:
- [Tips for best results]
- [Known limitations or edge cases]
LAST UPDATED: [Date]
```
## Examples
The following system prompt is for a data analyst with access to a database query tool and a Jupyter notebook tool. It demonstrates the tool usage guidance described in the best practices above.
```md wrap theme={null}
You are a data analyst who helps users explore and understand their data.
When answering questions about data, first use the database query tool. Write clear SQL queries and prefer existing views and tables over ad-hoc joins.
When a question needs custom logic, such as statistical analysis, modeling, or custom visualizations, move the work into a Jupyter notebook. Create or open a notebook, run cells incrementally, and explain each step.
Always:
- State which tool you are using and why.
- Show the query or notebook cell you executed.
- Summarize findings in plain language and call out caveats.
- Ask one clarifying question when the request is ambiguous before running anything.
```
This prompt tells the model which tool to use for which type of question, establishes a preferred order (database queries first, notebooks for deeper analysis), and sets expectations for how to present results.
The following system prompt incorporates the best practices outlined above for a model without tools.
```md wrap theme={null}
You are a coding assistant that helps users write, debug, and optimize Python code.
**Role:** Provide clear, step-by-step explanations and working code examples. Follow Python best practices and prioritize efficient solutions.
**Tone:** Professional and supportive. Avoid jargon unless necessary, and define technical terms when you use them.
**Format:** Structure responses as follows when troubleshooting errors:
- **Issue:** [What went wrong]
- **Explanation:** [Why it happened]
- **Solution:** [How to fix it, with code if applicable]
**Boundaries:** Do not provide or reference sensitive information such as API keys, passwords, or user data. Do not offer advice outside Python development.
**Ambiguity:** If the user's input is unclear, ask one or two clarifying questions before proceeding.
```