# Classifier

### Classifier Tool

The `minded-classifier` tool categorizes text using AI. It can be used in flows or directly in code.

#### Using in Flows

Use the tool in your flows by referencing `minded-classifier`:

```yaml
- id: classifyUserIntent
  type: tool
  toolName: minded-classifier
  prompt: |
    Classify the user's message into one of these categories:
    - Technical Issue: Problems with the system
    - Billing: Payment or pricing questions
    - Feature Request: Asking for new features
```

#### Tool Parameters

| Parameter     | Type             | Description                           | Required |
| ------------- | ---------------- | ------------------------------------- | -------- |
| content       | string           | Text content to classify              | Yes      |
| classes       | array            | Classes (strings, tuples, or objects) | No\*     |
| systemPrompt  | string           | Custom system prompt                  | No       |
| includeReason | boolean          | Include reasoning (default: true)     | No       |
| outputFormat  | 'json' \| 'text' | Output format (default: 'json')       | No       |
| defaultClass  | string           | Fallback class                        | No       |
| defaultReason | string           | Fallback reason                       | No       |

\*Classes can be provided in parameters or stored in agent memory.

#### Overriding Classifier Parameters in Flows

You can override classifier parameters directly in your flow YAML for deterministic classification:

```yaml
- name: 'Classify Support Ticket'
  type: 'tool'
  toolName: 'minded-classifier'
  parameters:
    # Dynamic - from state
    content: '{state.memory.ticketDescription}'
    # Fixed - predefined classes
    classes:
      - name: 'urgent'
        description: 'Requires immediate attention'
      - name: 'standard'
        description: 'Normal priority'
      - name: 'low'
        description: 'Can be handled later'
    # Fixed - configuration
    includeReason: true
    defaultClass: 'standard'
    # Let AI infer: systemPrompt (optional override)
```

### Using as a Utility

#### Import the utilities

```typescript
import { toolsLibrary } from '@minded-ai/mindedjs';

const { classify, createClassifier, createConversationClassifier, multiClassify } = toolsLibrary.tools['minded-classifier'];
```

#### Direct classification

```typescript
const result = await classify(
  "I can't access my account",
  {
    classes: [
      { name: 'Technical', description: 'Technical issues' },
      { name: 'Account', description: 'Account access problems' },
    ],
    includeReason: true,
  },
  agent.llm,
);

console.log(result);
// { class: 'Account', reason: 'User cannot access their account', confidence: 0.95 }
```

#### Create reusable classifiers

```typescript
// Simple classifier with string classes
const sentimentClassifier = createClassifier(['positive', 'negative', 'neutral']);

// Classifier with descriptions
const intentClassifier = createClassifier([
  ['greeting', 'User is greeting or saying hello'],
  ['question', 'User is asking a question'],
  ['complaint', 'User is complaining or expressing dissatisfaction'],
  ['goodbye', 'User is saying goodbye or ending conversation'],
]);

// Use the classifier
const sentiment = await sentimentClassifier('This is amazing!', agent.llm);
const intent = await intentClassifier('Hello there!', agent.llm);
```

#### Conversation classification

```typescript
const conversationClassifier = createConversationClassifier([
  { name: 'Resolved', description: 'Issue was resolved successfully' },
  { name: 'Escalated', description: 'Needs escalation to human agent' },
  { name: 'Pending', description: 'Awaiting more information' },
]);

const result = await conversationClassifier(messages, agent.llm);
```

#### Multi-label classification

```typescript
const topics = await multiClassify(
  'The app crashes on login and the UI looks outdated',
  {
    classes: [
      { name: 'Bug', description: 'Software bugs or crashes' },
      { name: 'UI/UX', description: 'User interface issues' },
      { name: 'Authentication', description: 'Login or auth problems' },
    ],
    maxClasses: 3,
  },
  agent.llm,
);

console.log(topics);
// [
//   { class: 'Bug', reason: 'App crashes', confidence: 0.9 },
//   { class: 'Authentication', reason: 'Login issues', confidence: 0.85 },
//   { class: 'UI/UX', reason: 'Outdated UI', confidence: 0.7 }
// ]
```

### Configuration

#### `ClassifierConfig` interface

```typescript
interface ClassifierConfig {
  classes: ClassDefinition[];
  systemPrompt?: string;
  outputFormat?: 'json' | 'text';
  includeReason?: boolean;
  defaultClass?: string;
  defaultReason?: string;
}
```