**2) Daily limit dashboard**
You can view your daily limit usage by going to your user account at [https://auth.zencoder.ai](https://auth.zencoder.ai). Once logged in, navigate to the User Profile page where you'll find a "Limits" tab. You can also access it directly here.
3. After signing out, you'll see large buttons to sign in - just follow the process
JetBrains IDEs (IntelliJ, PyCharm, WebStorm, etc.)
1. Open Settings (On macOS: Press `Command + ,`, On Windows/Linux: Press `Ctrl + Alt + S` or go to `File > Settings`)
2. Navigate to `Tools > Zencoder`
3. Click the `Authenticate` button under "Launch authentication process"
4. Follow the prompts to sign out and sign back in
Tab or your mouse to accept the suggested code snippet. Refine as needed to align with your project’s requirements.
Generate a basic Python script that reads a CSV file.
2. Zencoder will instantly generate functional, contextually relevant code based on your prompt.
Refactor this code into the chat prompt and hit submit.
Debug this code or Debug this error.
2. Submit your request to initiate Zencoder’s debugging process.
Ctrl + L (Windows) / CMD + L (Mac) to copy the selection into the chat window
Generate docstring with best practices into the chat, then hit submit
Generate documentation for this file
* Create a README for this project
* Document the API in this module
Then use prompts like:
```
Generate E2E tests for my repo
```
```
Create E2E Playwright tests for the login flow
```
```
Generate E2E Cypress tests for the shopping cart functionality
```
Ctrl+Shift+X.
Cmd+Shift+X.
#### 2. Add a connection to Github (Gitlab and Bitbucket coming soon)
Create a connection to your version control system:
1. Click on `Connections` in the admin panel
2. Select `Add`
3. Choose GitHub as your VCS provider
4. Complete the OAuth authorization process
## Using Multi-Repository Search
### Automatic Agent Detection
Since Multi-Repository Search is implemented as an agent tool, by default it is available for the [coding agent](/features/coding-agent), but needs to be configured manually for [custom agents](/features/ai-agents) (this functionality is coming soon).
Once configured, multi-repository search tool works with your existing workflow:
* **No special commands** are needed as AI agents automatically detect when you reference other repositories
* **Zencoder context understanding** allows agents to use repository names, service names, or project references to trigger searches
### Example Interactions
```
User: "How is authentication handled in the user-service repository?
Use the multi-repo search tool to find relevant code."
Agent: [Automatically searches user-service repository for
authentication patterns]
Based on the user-service repository, authentication is
handled using JWT tokens with...
```
```
User: "Use the multi-repo search tool to find and then implement
the same error handling pattern used in the payment-api".
Agent: [Searches payment-api repository for error handling patterns]
I found the error handling pattern in payment-api.
Here's how to implement it in your current project...
```
## Best Practices
To get the most out of Multi-Repository Search, follow these guidelines for optimal results:
### Be Specific with Repository References and Tool Usage
For optimal search behavior, avoid making vague requests as agents might use the search tool excessively.
Instead, be specific when referencing repositories or services. Use exact repository names like "user-service" rather than generic terms like "the user thing" or "that authentication repo."
Also, since the Multi-repo search is a tool, you can be explicit in asking the agent to use it. This helps agents target their searches more effectively and return more relevant results.
### Consider Repository Size and Scope
Very large repositories may take longer to index initially, so consider the scope of your searches to get the most relevant results. When working with extensive codebases, provide additional context about which parts of the repository are most relevant to your current task.
### Provide Clear Context
The more context you provide about what you're looking for across repositories, the better the search results will be. Instead of asking "How does authentication work?", try "How is JWT token validation implemented in the auth-service repository? Use repo search tool."
This specificity helps agents understand exactly what information to retrieve.
## Related Features
Multi-Repository Search works with other Zencoder capabilities:
Then use the prompt:
```
Generate repo.md file with information from my repo
```
Example prompts to get started:
```
Generate unit tests for the calculateTax function
```
```
Create unit tests for the UserService class
```
```
Generate unit tests for the authentication logic
```
*Note: The Code Lens appearance may vary slightly between VS Code and JetBrains IDEs, and might need to be enabled in your IDE settings.*
This allows you to apply specific rules on-demand, in addition to rules that are automatically applied based on `alwaysApply: true` or matching glob patterns as described earlier.
## Rule File Format
Each rule file follows this structure:
```markdown
---
description: "Brief description of what this rule covers"
globs: ["*.ts", "*.tsx", "src/**/*.js"] # Optional: file patterns
alwaysApply: false # Optional: default is false
---
# Rule Content
Your markdown content here with guidelines, examples, and instructions.
```
### Frontmatter Fields
| Field | Required | Description |
| ------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `description` | **Yes** | Brief description of the rule's purpose. Displayed in chat when @mentioning rules and used by agents to understand rule relevance. Example: `"TypeScript coding guidelines and best practices"` |
| `globs` | No | Array of file patterns that trigger this rule. Rule is automatically included when working with matching files. Examples: `["*.ts", "*.tsx"]`, `["src/**/*.js"]`, `["*.md", "*.mdx"]` |
| `alwaysApply` | No | Boolean (default: false). When `true`, rule is included in every request regardless of file context. Note: When `true`, the `globs` field is ignored |
## Practical Examples
Here are two complete examples showing different types of rules and how they're structured:
Performs static analysis against repository-specific patterns. Validates syntax, imports, and dependencies. Checks for compatibility with existing code structures and naming conventions.
Implements error detection and correction cycles. Diagnoses specific issues, applies targeted fixes, and re-validates. Continues until code meets quality thresholds for integration with the codebase.
Provides common validation infrastructure for all specialized agents. Standardizes error handling, code quality checks, and repository context access across different code generation tasks.
Indexes repository structure, understands file dependencies, and uses numerous tools to understand your codebase. Indexes are updated continuously with incremental updates.
Processes relationships between code elements. Maps function calls, inheritance hierarchies, and data flow. Builds a comprehensive representation of code interactions and dependencies.
Provides internal real-time access to the code understanding graph. Enables context-aware code generation, completion, and analysis. Maintains repository-specific knowledge to ensure generated code matches existing patterns.