# Generate AI name

div
strong
🔨 In Development
 — This section is still being developed and may change.


Generate an intelligent thread title using AI based on conversation content. Supports streaming responses.

Generate an intelligent thread title using AI based on conversation content. Uses the last 10 messages for context and generates concise, descriptive titles. Supports streaming responses for real-time feedback.

You can optionally provide messages in the request body to avoid waiting for database saves (recommended for real-time UI updates).

#### Path Parameters

**`thread_id`** string required

The unique identifier of the thread to generate a name for.

#### Query Parameters

**`stream`** boolean optional · Defaults to `false`

Enable streaming mode to receive the generated name incrementally as it's created.

#### Request Body (Optional)

**`messages`** array optional

Array of message objects to use for name generation. If provided, these messages will be used instead of fetching from the database. This allows for instant name generation without waiting for database saves.

- **`role`** string required - Message role (`user` or `assistant`)
- **`content`** string required - Message content


**Behavior:**

- If `messages` provided: Uses messages from request body (no database lookup)
- If `messages` not provided: Fetches messages from database (existing behavior)


With Messages (Recommended)

```bash
curl -X POST "https://api.freddy.aitronos.com/v1/threads/thread_abc123/generateName" \
  -H "Authorization: Bearer $FREDDY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {
        "role": "user",
        "content": "How do I configure Docker volumes for my PostgreSQL database?"
      },
      {
        "role": "assistant",
        "content": "To configure Docker volumes for PostgreSQL, you can use named volumes..."
      }
    ]
  }'
```


```python
import requests

response = requests.post(
    "https://api.freddy.aitronos.com/v1/threads/thread_abc123/generateName",
    headers={
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    },
    json={
        "messages": [
            {
                "role": "user",
                "content": "How do I configure Docker volumes for my PostgreSQL database?"
            },
            {
                "role": "assistant",
                "content": "To configure Docker volumes for PostgreSQL, you can use named volumes..."
            }
        ]
    }
)

result = response.json()
print(f"Generated name: {result['name']}")
```


```javascript
const response = await fetch('https://api.freddy.aitronos.com/v1/threads/thread_abc123/generateName', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${apiKey}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    messages: [
      {
        role: 'user',
        content: 'How do I configure Docker volumes for my PostgreSQL database?'
      },
      {
        role: 'assistant',
        content: 'To configure Docker volumes for PostgreSQL, you can use named volumes...'
      }
    ]
  })
});

const result = await response.json();
console.log(`Generated name: ${result.name}`);
```

From Database

```bash
curl -X POST "https://api.freddy.aitronos.com/v1/threads/thread_abc123/generateName" \
  -H "Authorization: Bearer $FREDDY_API_KEY"
```


```python
import requests

response = requests.post(
    "https://api.freddy.aitronos.com/v1/threads/thread_abc123/generateName",
    headers={"Authorization": f"Bearer {api_key}"}
)

result = response.json()
print(f"Generated name: {result['name']}")
```


```javascript
const response = await fetch('https://api.freddy.aitronos.com/v1/threads/thread_abc123/generateName', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${apiKey}`
  }
});

const result = await response.json();
console.log(`Generated name: ${result.name}`);
```

Streaming

```bash
curl -X POST "https://api.freddy.aitronos.com/v1/threads/thread_abc123/generateName?stream=true" \
  -H "Authorization: Bearer $FREDDY_API_KEY" \
  -H "Accept: text/event-stream"
```


```python
import requests

response = requests.post(
    "https://api.freddy.aitronos.com/v1/threads/thread_abc123/generateName",
    headers={"Authorization": f"Bearer {api_key}"},
    params={"stream": True},
    stream=True
)

for line in response.iter_lines():
    if line:
        print(f"Stream: {line.decode('utf-8')}")
```


```javascript
const response = await fetch('https://api.freddy.aitronos.com/v1/threads/thread_abc123/generateName?stream=true', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${apiKey}`,
    'Accept': 'text/event-stream'
  }
});

const reader = response.body.getReader();
const decoder = new TextDecoder();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  
  const chunk = decoder.decode(value);
  console.log('Stream:', chunk);
}
```

## Response

200 OK

```json
{
  "success": true,
  "threadId": "thread_abc123",
  "name": "Customer Support Query",
  "message": "Thread name generated successfully"
}
```

Streaming Response

```
data: {"type": "name_generation_started", "threadId": "thread_abc123"}

data: {"type": "name_generation_progress", "progress": 50}

data: {"type": "name_generation_complete", "name": "Customer Support Query", "threadId": "thread_abc123"}

data: [DONE]
```

Errors

```json 404 Not Found
{
  "error": {
    "message": "Thread not found or access denied",
    "type": "not_found_error",
    "code": "thread_not_found"
  }
}
```


```json 400 Bad Request - No Messages
{
  "detail": "Cannot generate thread name: no messages in thread yet. Please wait for messages to be saved or provide messages in request body."
}
```


```json 400 Bad Request - Empty Messages
{
  "detail": "Cannot generate thread name: messages exist but contain no valid content."
}
```


```json 500 Server Error
{
  "error": {
    "message": "Failed to generate thread name",
    "type": "server_error",
    "code": "name_generation_failed"
  }
}
```

## AI Naming Logic

The AI name generation uses the following logic:

- **Context Analysis**: Analyzes up to 10 messages from the thread (or provided messages)
- **Title Generation**: Creates concise, descriptive titles (2-5 words, maximum 50 characters)
- **Focus on User Intent**: Prioritizes user messages to understand what the user is asking about
- **Intelligent Cleanup**: Removes unnecessary prefixes, quotes, trailing punctuation
- **Title Case Formatting**: Ensures proper capitalization for readability
- **Fallback Handling**: Returns "Untitled" if generation fails
- **Content Awareness**: Considers conversation topics, user intent, and context


### Name Generation Model

- Uses `ftg-3.0-speed` for fast, efficient title generation
- No default system instructions to prevent bias
- Focused prompt explicitly emphasizing user messages and context
- Internal usage tracking (not visible in UI)


## Use Cases

### Recommended: Pass Messages in Request Body

✅ **Best for:**

- Real-time UI updates (no database wait)
- Streaming responses (generate name immediately after response)
- `storeResponses=false` scenarios
- Avoiding race conditions with message saving



```javascript
// After streaming response completes
const nameResponse = await fetch(`/v1/threads/${threadId}/generateName`, {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
  body: JSON.stringify({
    messages: [
      { role: 'user', content: userMessage },
      { role: 'assistant', content: assistantResponse }
    ]
  })
});
```

### Alternative: Fetch from Database

✅ **Best for:**

- Background name generation
- Threads with existing saved messages
- Regenerating names for old threads



```javascript
// For existing threads with saved messages
await fetch(`/v1/threads/${threadId}/generateName`, {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${apiKey}` }
});
```

## Benefits

| Feature | With Messages Parameter | From Database |
|  --- | --- | --- |
| **Latency** | Instant (no DB lookup) | Requires DB read |
| **Race Conditions** | None | Possible if messages not saved yet |
| **Works with `storeResponses=false`** | ✅ Yes | ❌ No |
| **Real-time UI** | ✅ Recommended | ⚠️ Requires delay |
| **Backward Compatible** | ✅ Yes | ✅ Yes |


## Related Resources

- [Threads Overview](/docs/documentation/core-concepts/threads-overview)
- [Rename Thread](/docs/api-reference/threads/rename)
- [Create Thread](/docs/api-reference/threads/create)
- [Thread Context Modes](/docs/documentation/core-concepts/thread-context-modes)