​
How to make your agent aware of codebases and documentation

AI coding agents work best when they understand the context of your project. This guide shows you how to give your agent access to codebases and documentation, making it more helpful and accurate.

​
Make your agent aware of your open codebase

When your agent understands your current codebase, it can provide more relevant suggestions and answers.

​
Let your agent explore the codebase using tools

Your agent can use built-in tools to navigate and understand your code:
  1. File exploration tools: The agent can read files, search for patterns, and understand project structure
  2. Code search: Use search to find relevant code snippets
  3. Git integration: Access commit history and understand code evolution

​
Create rules to help the agent understand your codebase

Rules guide your agent’s behavior and understanding. Place markdown files in .continue/rules in your project to provide context: 
# Project Architecture

This is a React application with:
- Components in `/src/components`
- API routes in `/src/api`
- State management using Redux in `/src/store`

## Coding Standards
- Use TypeScript for all new files
- Follow the existing naming conventions
- Write tests for all new features
Place rules files at different levels of your project hierarchy to scope when they trigger
Learn more about rules configuration.

​
Make your agent aware of other codebases

Sometimes you need your agent to understand code beyond your current project.

​
Public codebases

For open-source projects and public repositories, you have several options: Create rules that point to external codebases: 
# External Dependencies

Our authentication system is based on:
- [Auth.js documentation](https://authjs.dev/)
- [Example implementation](https://github.com/nextauthjs/next-auth-example)

When implementing auth features, reference these patterns.

​
GitHub and GitLab CLIs

Enable gh or glab CLI access for your agent to interact with repositories. Add rules to guide CLI usage: 
# Repository Access

You can use the `gh` CLI to:
- Search for issues: `gh issue list --repo owner/repo`
- View pull requests: `gh pr list --repo owner/repo`
- Clone repositories: `gh repo clone owner/repo`

​
DeepWiki MCP

DeepWiki MCP lets your agent explore any public GitHub repository. 

Once configured, your agent can explore repositories like:
- "Explore the React repository structure"
- "Find how authentication is implemented in NextAuth.js"

### Internal codebases

For private and internal repositories, you need additional setup:

#### Custom MCP servers

Create an MCP server that has access to your internal repositories.

#### Custom code RAG

For faster retrieval and lower costs with very large internal codebases, consider implementing a [custom code RAG](/guides/custom-code-rag) system. This is an advanced approach that requires more setup but can provide performance benefits at scale.

## Make your agent aware of relevant documentation

Documentation provides crucial context for your agent to understand APIs, frameworks, and best practices.

### Public documentation

#### Rules with documentation links

Guide your agent to relevant documentation:

```markdown
# Documentation Resources

For framework-specific questions, refer to:
- React: https://react.dev/reference/react
- Next.js: https://nextjs.org/docs
- Tailwind CSS: https://tailwindcss.com/docs

Always cite documentation when explaining concepts.

​
Context7 MCP

Context7 MCP enables your agent to search and retrieve information from public documentation: Your agent can then answer questions like:
  • “How do I use React hooks?”
  • “What’s the syntax for Tailwind CSS animations?”

​
Internal documentation

For private documentation and wikis: Create rules that reference internal resources: 
# Internal Documentation

Our team documentation is available at:
- API Documentation: https://internal.docs/api
- Architecture Guide: https://internal.docs/architecture
- Deployment Process: https://internal.docs/deployment

Always follow our internal standards when suggesting code.

​
Custom MCP servers for docs

Create an MCP server that accesses your internal documentation.

​
Migrating from deprecated context providers

If you were previously using the @Codebase or @Docs context providers, here’s how to migrate to the new approach:

​
Migrating from @Codebase

The @Codebase context provider has been deprecated. Instead:
  1. Use built-in tools: Your agent can now use file exploration and search tools to understand your codebase
  2. Add rules: Create .continue/rules files to provide context about your project structure
  3. Use MCP servers: For external codebases, use DeepWiki MCP or custom MCP servers

​
Migrating from @Docs

The @Docs context provider has been deprecated. Instead:
  1. Use Context7 MCP: For public documentation, Context7 MCP provides similar functionality
  2. Add documentation links in rules: Create rules that reference documentation URLs
  3. Use custom MCP servers: For internal documentation, create an MCP server with access to your docs
The new approach provides better integration with Continue’s Agent features and more intelligent context selection.

​
Next steps