> ## Documentation Index
> Fetch the complete documentation index at: https://praison.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# AutoRag Agent

> Automatic retrieval-augmented generation with smart query detection

Automatically retrieve relevant context based on query analysis with AutoRagAgent.

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
graph LR
    subgraph "AutoRag Flow"
        A[📝 Query] --> B{🔍 Analyze}
        B -->|Needs Context| C[📚 Retrieve]
        B -->|No Context| D[🤖 Direct]
        C --> E[🧠 Generate]
        D --> E
        E --> F[📤 Response]
    end
    
    classDef query fill:#6366F1,stroke:#7C90A0,color:#fff
    classDef analyze fill:#F59E0B,stroke:#7C90A0,color:#fff
    classDef retrieve fill:#189AB4,stroke:#7C90A0,color:#fff
    classDef generate fill:#8B0000,stroke:#7C90A0,color:#fff
    classDef response fill:#10B981,stroke:#7C90A0,color:#fff
    
    class A query
    class B analyze
    class C,D retrieve
    class E generate
    class F response
    classDef agent fill:#8B0000,color:#fff
    classDef tool fill:#189AB4,color:#fff
```

## Quick Start

**1. Create AutoRagAgent**

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
import { AutoRagAgent, RetrievalPolicy } from 'praisonai';

const autoRag = new AutoRagAgent({
  retrievalPolicy: RetrievalPolicy.AUTO,
  topK: 5,
  rerank: true
});
```

**2. Check if Retrieval Needed**

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
// Queries that trigger retrieval
autoRag.shouldRetrieve("What is machine learning?");  // true
autoRag.shouldRetrieve("Explain the document");       // true
autoRag.shouldRetrieve("Find information about AI");  // true

// Queries that don't trigger retrieval
autoRag.shouldRetrieve("Hi");                         // false
autoRag.shouldRetrieve("Thanks");                     // false
```

***

## Retrieval Policies

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
graph TB
    subgraph "Choose Your Policy"
        A{When to retrieve?}
        A -->|Smart detection| B[🔮 AUTO]
        A -->|Every query| C[📚 ALWAYS]
        A -->|Never| D[🚫 NEVER]
    end
    
    classDef question fill:#6366F1,stroke:#7C90A0,color:#fff
    classDef auto fill:#10B981,stroke:#7C90A0,color:#fff
    classDef always fill:#F59E0B,stroke:#7C90A0,color:#fff
    classDef never fill:#8B0000,stroke:#7C90A0,color:#fff
    
    class A question
    class B auto
    class C always
    class D never
```

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
import { RetrievalPolicy } from 'praisonai';

RetrievalPolicy.AUTO    // Smart detection based on query
RetrievalPolicy.ALWAYS  // Always retrieve context
RetrievalPolicy.NEVER   // Never retrieve context
```

***

## Configuration

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
import { AutoRagAgent, AutoRagAgentConfig, RetrievalPolicy } from 'praisonai';

const config: AutoRagAgentConfig = {
  retrievalPolicy: RetrievalPolicy.AUTO,
  topK: 5,                    // Number of results to retrieve
  hybrid: false,              // Use hybrid search
  rerank: true,               // Rerank results
  includeCitations: true,     // Include citations in response
  citationsMode: 'append',    // 'append' | 'hidden' | 'none'
  maxContextTokens: 4000,     // Max tokens for context
  autoMinLength: 10           // Min query length for auto mode
};

const autoRag = new AutoRagAgent(config);
```

### Configuration Options

| Option | Type | Default | Description |
| - | - | - | - |
| `retrievalPolicy` | `RetrievalPolicy` | `AUTO` | When to retrieve context |
| `topK` | `number` | `5` | Number of results to retrieve |
| `hybrid` | `boolean` | `false` | Use hybrid (keyword + semantic) search |
| `rerank` | `boolean` | `false` | Rerank results for relevance |
| `includeCitations` | `boolean` | `true` | Include source citations |
| `citationsMode` | `string` | `'append'` | How to show citations |
| `maxContextTokens` | `number` | `4000` | Max context window |
| `autoMinLength` | `number` | `10` | Min query length for AUTO |

***

## Auto Keywords

Queries containing these keywords trigger retrieval in AUTO mode:

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
import { DEFAULT_AUTO_KEYWORDS } from 'praisonai';

// Default keywords that trigger retrieval
const keywords = [
  'what', 'how', 'why', 'when', 'where', 'who', 'which',
  'explain', 'describe', 'summarize', 'find', 'search',
  'tell me', 'show me', 'according to', 'based on',
  'cite', 'source', 'reference', 'document', 'paper'
];
```

### Custom Keywords

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
const autoRag = new AutoRagAgent({
  retrievalPolicy: RetrievalPolicy.AUTO,
  autoKeywords: new Set([
    'what', 'how', 'explain',
    'my custom keyword',
    'another trigger'
  ])
});
```

***

## Methods

### shouldRetrieve

Check if a query should trigger retrieval:

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
const autoRag = new AutoRagAgent();

// Returns true for questions
autoRag.shouldRetrieve("What is the capital of France?");  // true

// Returns true for search queries
autoRag.shouldRetrieve("Find documents about AI");         // true

// Returns false for short queries
autoRag.shouldRetrieve("Hi");                              // false

// Returns false for non-question statements
autoRag.shouldRetrieve("Thanks for your help");            // false
```

### getConfig

Get the current configuration:

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
const config = autoRag.getConfig();
console.log(config.topK);           // 5
console.log(config.retrievalPolicy); // 'auto'
```

***

## Common Patterns

> [tab] With Knowledge Base
>
> ```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
> import { AutoRagAgent, RetrievalPolicy, Knowledge } from 'praisonai';
>
> const knowledge = new Knowledge();
> await knowledge.add('./docs', { userId: 'u1' });
>
> const autoRag = new AutoRagAgent({
>   retrievalPolicy: RetrievalPolicy.AUTO,
>   topK: 5,
>   rerank: true
> });
>
> async function answer(query: string) {
>   if (autoRag.shouldRetrieve(query)) {
>     const found = await knowledge.search(query, { userId: 'u1', limit: 5 });
>     return generateWithContext(query, found.results);
>   }
>   return generateDirect(query);
> }
> ```

> [tab] With Agent
>
> ```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
> import { Agent, AutoRagAgent, RetrievalPolicy } from 'praisonai';
>
> const autoRag = new AutoRagAgent({
>   retrievalPolicy: RetrievalPolicy.AUTO
> });
>
> const agent = new Agent({
>   name: "RAG Assistant",
>   instructions: "Answer questions using retrieved context"
> });
>
> async function chat(query: string) {
>   const needsContext = autoRag.shouldRetrieve(query);
>
>   if (needsContext) {
>     // Add context to the query
>     const context = await retrieveContext(query);
>     return agent.start(`Context: ${context}\n\nQuestion: ${query}`);
>   }
>
>   return agent.start(query);
> }
> ```

***

## API Reference

> [card] [AutoRagAgent](https://praison.ai/docs/sdk/reference/typescript/classes/AutoRagAgent.md)
>
> AutoRagAgent class reference

> [card] [AutoRagAgentConfig](https://praison.ai/docs/sdk/reference/typescript/classes/AutoRagAgentConfig.md)
>
> Configuration options

***

## Best Practices

> [accordion] Use AUTO for general chatbots
>
> AUTO mode balances retrieval costs with response quality for most use cases.

> [accordion] Use ALWAYS for document Q\&A
>
> When every query relates to documents, use ALWAYS to ensure context is included.

> [accordion] Enable reranking for accuracy
>
> Reranking improves result relevance at a small latency cost.

> [accordion] Tune autoMinLength
>
> Increase `autoMinLength` to avoid retrieval for very short queries.

***

## Related

> [card] [RAG Agent](https://praison.ai/docs/js/rag-agent.md)
>
> Full RAG implementation

> [card] [Knowledge Base](https://praison.ai/docs/js/knowledge-base.md)
>
> Build knowledge bases


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.