fix(sdk): removing deprecating param from our sdk and docs changes with it (#4740)
This commit is contained in:
Kartik
@@ -1,6 +1,6 @@
|
||||
---
|
||||
title: Advanced Retrieval
|
||||
description: "Advanced memory search with keyword expansion, intelligent reranking, and precision filtering"
|
||||
description: "Advanced memory search with intelligent reranking for precise results"
|
||||
---
|
||||
|
||||
## What is Advanced Retrieval?
|
||||
@@ -9,40 +9,6 @@ Advanced Retrieval gives you precise control over how memories are found and ran
|
||||
|
||||
## Search Enhancement Options
|
||||
|
||||
### Keyword Search
|
||||
|
||||
Expands results to include memories with specific terms, names, and technical keywords.
|
||||
|
||||
<Tabs>
|
||||
<Tab title="When to Use">
|
||||
- Searching for specific entities, names, or technical terms
|
||||
- Need comprehensive coverage of a topic
|
||||
- Want broader recall even if some results are less relevant
|
||||
- Working with domain-specific terminology
|
||||
</Tab>
|
||||
<Tab title="How it Works">
|
||||
```python Python
|
||||
# Find memories containing specific food-related terms
|
||||
results = client.search(
|
||||
query="What foods should I avoid?",
|
||||
keyword_search=True,
|
||||
user_id="user123"
|
||||
)
|
||||
|
||||
# Results might include:
|
||||
# ✓ "Allergic to peanuts and shellfish"
|
||||
# ✓ "Lactose intolerant - avoid dairy"
|
||||
# ✓ "Mentioned avoiding gluten last week"
|
||||
```
|
||||
</Tab>
|
||||
<Tab title="Performance">
|
||||
- **Latency**: ~10ms additional
|
||||
- **Recall**: Significantly increased
|
||||
- **Precision**: Slightly decreased
|
||||
- **Best for**: Entity search, comprehensive coverage
|
||||
</Tab>
|
||||
</Tabs>
|
||||
|
||||
### Reranking
|
||||
|
||||
Reorders results using deep semantic understanding to put the most relevant memories first.
|
||||
@@ -77,41 +43,6 @@ results = client.search(
|
||||
</Tab>
|
||||
</Tabs>
|
||||
|
||||
### Memory Filtering
|
||||
|
||||
Filters results to keep only the most precisely relevant memories.
|
||||
|
||||
<Tabs>
|
||||
<Tab title="When to Use">
|
||||
- Need highly specific, focused results
|
||||
- Working with large datasets where noise is problematic
|
||||
- Quality over quantity is essential
|
||||
- Building production or safety-critical applications
|
||||
</Tab>
|
||||
<Tab title="How it Works">
|
||||
```python Python
|
||||
# Get only the most relevant dietary restrictions
|
||||
results = client.search(
|
||||
query="What are my dietary restrictions?",
|
||||
filter_memories=True,
|
||||
user_id="user123"
|
||||
)
|
||||
|
||||
# Before filtering: After filtering:
|
||||
# • "Allergic to nuts" → • "Allergic to nuts"
|
||||
# • "Likes Italian food" → • "Vegetarian diet"
|
||||
# • "Vegetarian diet" →
|
||||
# • "Eats dinner at 7pm" →
|
||||
```
|
||||
</Tab>
|
||||
<Tab title="Performance">
|
||||
- **Latency**: 200-300ms additional
|
||||
- **Precision**: Maximized
|
||||
- **Recall**: May be reduced
|
||||
- **Best for**: Focused queries, production systems
|
||||
</Tab>
|
||||
</Tabs>
|
||||
|
||||
## Real-World Use Cases
|
||||
|
||||
<Tabs>
|
||||
@@ -120,7 +51,6 @@ results = client.search(
|
||||
# Smart home assistant finding device preferences
|
||||
results = client.search(
|
||||
query="How do I like my bedroom temperature?",
|
||||
keyword_search=True, # Find specific temperature mentions
|
||||
rerank=True, # Get most recent preferences first
|
||||
user_id="user123"
|
||||
)
|
||||
@@ -133,8 +63,6 @@ results = client.search(
|
||||
# Find specific product issues with high precision
|
||||
results = client.search(
|
||||
query="Problems with premium subscription billing",
|
||||
keyword_search=True, # Find "premium", "billing", "subscription"
|
||||
filter_memories=True, # Only billing-related issues
|
||||
user_id="customer456"
|
||||
)
|
||||
|
||||
@@ -147,11 +75,10 @@ results = client.search(
|
||||
results = client.search(
|
||||
query="Patient allergies and contraindications",
|
||||
rerank=True, # Most important info first
|
||||
filter_memories=True, # Only medical restrictions
|
||||
user_id="patient789"
|
||||
)
|
||||
|
||||
# Ensures critical allergy info appears first and filters out non-medical data
|
||||
# Ensures critical allergy info appears first
|
||||
```
|
||||
</Tab>
|
||||
<Tab title="Learning Platform">
|
||||
@@ -159,7 +86,6 @@ results = client.search(
|
||||
# Find learning progress for specific topics
|
||||
results = client.search(
|
||||
query="Python programming progress and difficulties",
|
||||
keyword_search=True, # Find "Python", "programming", specific concepts
|
||||
rerank=True, # Recent progress first
|
||||
user_id="student123"
|
||||
)
|
||||
@@ -169,63 +95,57 @@ results = client.search(
|
||||
</Tab>
|
||||
</Tabs>
|
||||
|
||||
## Choosing the Right Combination
|
||||
## Choosing the Right Configuration
|
||||
|
||||
### Recommended Configurations
|
||||
|
||||
<CodeGroup>
|
||||
```python Python
|
||||
# Fast and broad - good for exploration
|
||||
# Basic search - good for exploration
|
||||
def quick_search(query, user_id):
|
||||
return client.search(
|
||||
query=query,
|
||||
keyword_search=True,
|
||||
user_id=user_id
|
||||
)
|
||||
|
||||
# Balanced - good for most applications
|
||||
# Reranked search - good for most applications
|
||||
def standard_search(query, user_id):
|
||||
return client.search(
|
||||
query=query,
|
||||
keyword_search=True,
|
||||
rerank=True,
|
||||
user_id=user_id
|
||||
)
|
||||
|
||||
# High precision - good for critical applications
|
||||
# Reranked search - good for critical applications
|
||||
def precise_search(query, user_id):
|
||||
return client.search(
|
||||
query=query,
|
||||
rerank=True,
|
||||
filter_memories=True,
|
||||
user_id=user_id
|
||||
)
|
||||
```
|
||||
|
||||
```javascript JavaScript
|
||||
// Fast and broad - good for exploration
|
||||
// Basic search - good for exploration
|
||||
function quickSearch(query, userId) {
|
||||
return client.search(query, {
|
||||
user_id: userId,
|
||||
keyword_search: true
|
||||
user_id: userId
|
||||
});
|
||||
}
|
||||
|
||||
// Balanced - good for most applications
|
||||
// Reranked search - good for most applications
|
||||
function standardSearch(query, userId) {
|
||||
return client.search(query, {
|
||||
user_id: userId,
|
||||
keyword_search: true,
|
||||
rerank: true
|
||||
});
|
||||
}
|
||||
|
||||
// High precision - good for critical applications
|
||||
// Reranked search - good for critical applications
|
||||
function preciseSearch(query, userId) {
|
||||
return client.search(query, {
|
||||
user_id: userId,
|
||||
rerank: true,
|
||||
filter_memories: true
|
||||
rerank: true
|
||||
});
|
||||
}
|
||||
```
|
||||
@@ -235,19 +155,15 @@ function preciseSearch(query, userId) {
|
||||
|
||||
### Do
|
||||
|
||||
- Start simple with just one enhancement and measure impact
|
||||
- Use keyword search for entity-heavy queries (names, places, technical terms)
|
||||
- Start simple with basic search and measure impact before enabling reranking
|
||||
- Use reranking when the top result quality matters most
|
||||
- Use filtering for production systems where precision is critical
|
||||
- Handle empty results gracefully when filtering is too aggressive
|
||||
- Monitor latency and adjust based on your application's needs
|
||||
- Handle empty results gracefully
|
||||
|
||||
### Don't
|
||||
|
||||
- Enable all options by default without measuring necessity
|
||||
- Use filtering for broad exploratory queries
|
||||
- Enable reranking by default without measuring necessity
|
||||
- Ignore latency impact in real-time applications
|
||||
- Forget to handle cases where filtering returns no results
|
||||
- Use advanced retrieval for simple, fast lookup scenarios
|
||||
|
||||
## Performance Guidelines
|
||||
@@ -261,20 +177,18 @@ import time
|
||||
start_time = time.time()
|
||||
results = client.search(
|
||||
query="user preferences",
|
||||
keyword_search=True, # +10ms
|
||||
rerank=True, # +150ms
|
||||
filter_memories=True, # +250ms
|
||||
user_id="user123"
|
||||
)
|
||||
latency = time.time() - start_time
|
||||
print(f"Search completed in {latency:.2f}s") # ~0.41s expected
|
||||
print(f"Search completed in {latency:.2f}s")
|
||||
```
|
||||
|
||||
### Optimization Tips
|
||||
|
||||
1. **Cache frequent queries** to avoid repeated advanced processing
|
||||
2. **Use session-specific search** with `run_id` to reduce search space
|
||||
3. **Implement fallback logic** when filtering returns empty results
|
||||
3. **Implement fallback logic** when search returns empty results
|
||||
4. **Monitor and alert** on search latency patterns
|
||||
|
||||
<Snippet file="get-help.mdx" />
|
||||
|
||||
@@ -1,197 +0,0 @@
|
||||
---
|
||||
title: Async Mode Default Change
|
||||
description: "The async_mode parameter now defaults to true for all memory additions, changing from synchronous processing."
|
||||
---
|
||||
|
||||
<Note type="warning">
|
||||
**Important Change**
|
||||
|
||||
The `async_mode` parameter defaults to `true` for all memory additions, changing the default API behavior to asynchronous processing.
|
||||
</Note>
|
||||
|
||||
## Overview
|
||||
|
||||
The Memory Addition API processes all memory additions asynchronously by default. This change improves performance and scalability by queuing memory operations in the background, allowing your application to continue without waiting for memory processing to complete.
|
||||
|
||||
## What's Changing
|
||||
|
||||
The parameter `async_mode` will default to `true` instead of `false`.
|
||||
|
||||
This means memory additions will be **processed asynchronously** by default - queued for background execution instead of waiting for processing to complete.
|
||||
|
||||
## Behavior Comparison
|
||||
|
||||
### Old Default Behavior (async_mode = false)
|
||||
|
||||
When `async_mode` was set to `false`, the API returned fully processed memory objects immediately:
|
||||
|
||||
```json
|
||||
{
|
||||
"results": [
|
||||
{
|
||||
"id": "de0ee948-af6a-436c-835c-efb6705207de",
|
||||
"event": "ADD",
|
||||
"memory": "User Order #1234 was for a 'Nova 2000'",
|
||||
"structured_attributes": {
|
||||
"day": 13,
|
||||
"hour": 16,
|
||||
"year": 2025,
|
||||
"month": 10,
|
||||
"minute": 59,
|
||||
"quarter": 4,
|
||||
"is_weekend": false,
|
||||
"day_of_week": "monday",
|
||||
"day_of_year": 286,
|
||||
"week_of_year": 42
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
### New Default Behavior (async_mode = true)
|
||||
|
||||
With `async_mode` defaulting to `true`, memory processing is queued in the background and the API returns immediately:
|
||||
|
||||
```json
|
||||
{
|
||||
"results": [
|
||||
{
|
||||
"message": "Memory processing has been queued for background execution",
|
||||
"status": "PENDING",
|
||||
"event_id": "d7b5282a-0031-4cc2-98ba-5a02d8531e17"
|
||||
}
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
## Migration Guide
|
||||
|
||||
### If You Need Synchronous Processing
|
||||
|
||||
If your integration relies on receiving the processed memory object immediately, you can explicitly set `async_mode` to `false` in your requests:
|
||||
|
||||
<CodeGroup>
|
||||
|
||||
```python Python
|
||||
from mem0 import MemoryClient
|
||||
|
||||
client = MemoryClient(api_key="your-api-key")
|
||||
|
||||
# Explicitly set async_mode=False to preserve synchronous behavior
|
||||
messages = [
|
||||
{"role": "user", "content": "I ordered a Nova 2000"}
|
||||
]
|
||||
|
||||
result = client.add(
|
||||
messages,
|
||||
user_id="user-123",
|
||||
async_mode=False # This ensures synchronous processing
|
||||
)
|
||||
```
|
||||
|
||||
```javascript JavaScript
|
||||
const { MemoryClient } = require('mem0ai');
|
||||
|
||||
const client = new MemoryClient({ apiKey: 'your-api-key' });
|
||||
|
||||
// Explicitly set async_mode: false to preserve synchronous behavior
|
||||
const messages = [
|
||||
{ role: "user", content: "I ordered a Nova 2000" }
|
||||
];
|
||||
|
||||
const result = await client.add(messages, {
|
||||
user_id: "user-123",
|
||||
async_mode: false // This ensures synchronous processing
|
||||
});
|
||||
```
|
||||
|
||||
```bash cURL
|
||||
curl -X POST https://api.mem0.ai/v1/memories/ \
|
||||
-H "Authorization: Token your-api-key" \
|
||||
-H "Content-Type: application/json" \
|
||||
-d '{
|
||||
"messages": [
|
||||
{"role": "user", "content": "I ordered a Nova 2000"}
|
||||
],
|
||||
"user_id": "user-123",
|
||||
"async_mode": false
|
||||
}'
|
||||
```
|
||||
|
||||
</CodeGroup>
|
||||
|
||||
### If You Want to Adopt Asynchronous Processing
|
||||
|
||||
If you want to benefit from the improved performance of asynchronous processing:
|
||||
|
||||
1. **Remove** any explicit `async_mode=False` parameters from your code
|
||||
2. **Use webhooks** to receive notifications when memory processing completes
|
||||
|
||||
<Note>
|
||||
Learn more about [Webhooks](/platform/features/webhooks) for real-time notifications about memory events.
|
||||
</Note>
|
||||
|
||||
## Benefits of Asynchronous Processing
|
||||
|
||||
Switching to asynchronous processing provides several advantages:
|
||||
|
||||
- **Faster API Response Times**: Your application doesn't wait for memory processing
|
||||
- **Better Scalability**: Handle more memory additions concurrently
|
||||
- **Improved User Experience**: Reduced latency in your application
|
||||
- **Resource Efficiency**: Background processing optimizes server resources
|
||||
|
||||
## Important Notes
|
||||
|
||||
- The default behavior is now `async_mode=true` for asynchronous processing
|
||||
- Explicitly set `async_mode=false` if you need synchronous behavior
|
||||
- Use webhooks to receive notifications when memories are processed
|
||||
|
||||
## Monitoring Memory Processing
|
||||
|
||||
When using asynchronous mode, use webhooks to receive notifications about memory events:
|
||||
|
||||
<Card title="Configure Webhooks" icon="webhook" href="/platform/features/webhooks">
|
||||
Learn how to set up webhooks for memory processing events
|
||||
</Card>
|
||||
|
||||
You can also retrieve all processed memories at any time:
|
||||
|
||||
<CodeGroup>
|
||||
|
||||
```python Python
|
||||
# Retrieve all memories for a user
|
||||
# Note: get_all now requires filters
|
||||
memories = client.get_all(filters={"AND": [{"user_id": "user-123"}]})
|
||||
```
|
||||
|
||||
```javascript JavaScript
|
||||
// Retrieve all memories for a user
|
||||
// Note: getAll now requires filters
|
||||
const memories = await client.getAll({ filters: {"AND": [{"user_id": "user-123"}]} });
|
||||
```
|
||||
|
||||
</CodeGroup>
|
||||
|
||||
## Need Help?
|
||||
|
||||
If you have questions about this change or need assistance updating your integration:
|
||||
|
||||
<Snippet file="get-help.mdx" />
|
||||
|
||||
## Related Documentation
|
||||
|
||||
<CardGroup cols={2}>
|
||||
<Card title="Async Client" icon="bolt" href="/platform/features/async-client">
|
||||
Learn about the asynchronous client for Mem0
|
||||
</Card>
|
||||
<Card title="Add Memories API" icon="plus" href="/api-reference/memory/add-memories">
|
||||
View the complete API reference for adding memories
|
||||
</Card>
|
||||
<Card title="Webhooks" icon="webhook" href="/platform/features/webhooks">
|
||||
Configure webhooks for memory processing events
|
||||
</Card>
|
||||
<Card title="Memory Operations" icon="gear" href="/core-concepts/memory-operations/add">
|
||||
Understand memory addition operations
|
||||
</Card>
|
||||
</CardGroup>
|
||||
@@ -38,11 +38,7 @@ Before defining any criteria, make sure to initialize the `MemoryClient` with yo
|
||||
```python
|
||||
from mem0 import MemoryClient
|
||||
|
||||
client = MemoryClient(
|
||||
api_key="your_mem0_api_key",
|
||||
org_id="your_organization_id",
|
||||
project_id="your_project_id"
|
||||
)
|
||||
client = MemoryClient(api_key="your_mem0_api_key")
|
||||
```
|
||||
|
||||
### Define Your Criteria
|
||||
|
||||
@@ -98,7 +98,7 @@ messages = [
|
||||
]
|
||||
|
||||
# Add memories with project-level custom categories
|
||||
client.add(messages, user_id="alice", async_mode=False)
|
||||
client.add(messages, user_id="alice")
|
||||
```
|
||||
</CodeGroup>
|
||||
|
||||
@@ -187,7 +187,7 @@ messages = [
|
||||
]
|
||||
|
||||
# Add memories with default categories
|
||||
client.add(messages, user_id='alice', async_mode=False)
|
||||
client.add(messages, user_id='alice')
|
||||
```
|
||||
|
||||
```python Memories with categories
|
||||
|
||||
@@ -1,109 +0,0 @@
|
||||
---
|
||||
title: Expiration Date
|
||||
description: 'Set time-bound memories in Mem0 with automatic expiration dates to manage temporal information effectively.'
|
||||
---
|
||||
|
||||
## Benefits of Memory Expiration
|
||||
|
||||
Setting expiration dates for memories offers several advantages:
|
||||
|
||||
- **Time-Sensitive Information Management**: Handle information that is only relevant for a specific time period.
|
||||
- **Event-Based Memory**: Manage information related to upcoming events that becomes irrelevant after the event passes.
|
||||
|
||||
These benefits enable more sophisticated memory management for applications where temporal context matters.
|
||||
|
||||
## Setting Memory Expiration Date
|
||||
|
||||
You can set an expiration date for memories, after which they will no longer be retrieved in searches. This is useful for creating temporary memories or memories that are relevant only for a specific time period.
|
||||
|
||||
<CodeGroup>
|
||||
|
||||
```python Python
|
||||
import datetime
|
||||
from mem0 import MemoryClient
|
||||
|
||||
client = MemoryClient(api_key="your-api-key")
|
||||
|
||||
messages = [
|
||||
{
|
||||
"role": "user",
|
||||
"content": "I'll be in San Francisco until the end of this month."
|
||||
}
|
||||
]
|
||||
|
||||
# Set an expiration date for this memory
|
||||
client.add(messages=messages, user_id="alex", expiration_date=str(datetime.datetime.now().date() + datetime.timedelta(days=30)))
|
||||
|
||||
# You can also use an explicit date string
|
||||
client.add(messages=messages, user_id="alex", expiration_date="2023-08-31")
|
||||
```
|
||||
|
||||
```javascript JavaScript
|
||||
import MemoryClient from 'mem0ai';
|
||||
const client = new MemoryClient({ apiKey: 'your-api-key' });
|
||||
|
||||
const messages = [
|
||||
{
|
||||
"role": "user",
|
||||
"content": "I'll be in San Francisco until the end of this month."
|
||||
}
|
||||
];
|
||||
|
||||
// Set an expiration date 30 days from now
|
||||
const expirationDate = new Date();
|
||||
expirationDate.setDate(expirationDate.getDate() + 30);
|
||||
client.add(messages, {
|
||||
user_id: "alex",
|
||||
expiration_date: expirationDate.toISOString().split('T')[0]
|
||||
})
|
||||
.then(response => console.log(response))
|
||||
.catch(error => console.error(error));
|
||||
|
||||
// You can also use an explicit date string
|
||||
client.add(messages, {
|
||||
user_id: "alex",
|
||||
expiration_date: "2023-08-31"
|
||||
})
|
||||
.then(response => console.log(response))
|
||||
.catch(error => console.error(error));
|
||||
```
|
||||
|
||||
```bash cURL
|
||||
curl -X POST "https://api.mem0.ai/v1/memories/" \
|
||||
-H "Authorization: Token your-api-key" \
|
||||
-H "Content-Type: application/json" \
|
||||
-d '{
|
||||
"messages": [
|
||||
{
|
||||
"role": "user",
|
||||
"content": "I'll be in San Francisco until the end of this month."
|
||||
}
|
||||
],
|
||||
"user_id": "alex",
|
||||
"expiration_date": "2023-08-31"
|
||||
}'
|
||||
```
|
||||
|
||||
```json Output
|
||||
{
|
||||
"results": [
|
||||
{
|
||||
"id": "a1b2c3d4-e5f6-4g7h-8i9j-k0l1m2n3o4p5",
|
||||
"data": {
|
||||
"memory": "In San Francisco until the end of this month"
|
||||
},
|
||||
"event": "ADD"
|
||||
}
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
</CodeGroup>
|
||||
|
||||
<Note>
|
||||
Once a memory reaches its expiration date, it will not be included in search or get results, though the data remains stored in the system.
|
||||
</Note>
|
||||
|
||||
If you have any questions, please feel free to reach out to us using one of the following methods:
|
||||
|
||||
<Snippet file="get-help.mdx" />
|
||||
@@ -30,11 +30,7 @@ When adding new memories, enable Graph Memory to automatically build relationshi
|
||||
```python Python
|
||||
from mem0 import MemoryClient
|
||||
|
||||
client = MemoryClient(
|
||||
api_key="your-api-key",
|
||||
org_id="your-org-id",
|
||||
project_id="your-project-id"
|
||||
)
|
||||
client = MemoryClient(api_key="your-api-key")
|
||||
|
||||
messages = [
|
||||
{"role": "user", "content": "My name is Joseph"},
|
||||
@@ -53,11 +49,7 @@ client.add(
|
||||
```javascript JavaScript
|
||||
import { MemoryClient } from "mem0";
|
||||
|
||||
const client = new MemoryClient({
|
||||
apiKey: "your-api-key",
|
||||
org_id: "your-org-id",
|
||||
project_id: "your-project-id"
|
||||
});
|
||||
const client = new MemoryClient({ apiKey: "your-api-key" });
|
||||
|
||||
const messages = [
|
||||
{ role: "user", content: "My name is Joseph" },
|
||||
@@ -284,11 +276,7 @@ Instead of passing `enable_graph=True` to every add call, you can enable it once
|
||||
```python Python
|
||||
from mem0 import MemoryClient
|
||||
|
||||
client = MemoryClient(
|
||||
api_key="your-api-key",
|
||||
org_id="your-org-id",
|
||||
project_id="your-project-id"
|
||||
)
|
||||
client = MemoryClient(api_key="your-api-key")
|
||||
|
||||
# Enable graph memory for all operations in this project
|
||||
client.project.update(enable_graph=True)
|
||||
@@ -309,11 +297,7 @@ client.add(
|
||||
```javascript JavaScript
|
||||
import { MemoryClient } from "mem0";
|
||||
|
||||
const client = new MemoryClient({
|
||||
apiKey: "your-api-key",
|
||||
org_id: "your-org-id",
|
||||
project_id: "your-project-id"
|
||||
});
|
||||
const client = new MemoryClient({ apiKey: "your-api-key" });
|
||||
|
||||
// Enable graph memory for all operations in this project
|
||||
await client.project.update({ enable_graph: true });
|
||||
|
||||
@@ -217,17 +217,16 @@ print(search_response)
|
||||
|
||||
## Async Mode Support
|
||||
|
||||
Group chat also supports async processing for improved performance:
|
||||
Group chat supports async processing for improved performance. Memory additions are processed asynchronously by default.
|
||||
|
||||
<CodeGroup>
|
||||
|
||||
```python Python
|
||||
# Group chat with async mode
|
||||
# Group chat — async processing is the default
|
||||
response = client.add(
|
||||
messages,
|
||||
run_id="groupchat_async",
|
||||
infer=True,
|
||||
async_mode=True
|
||||
)
|
||||
print(response)
|
||||
```
|
||||
@@ -268,7 +267,7 @@ Each message in a group chat must include:
|
||||
|
||||
4. **Memory Filtering**: Use filters to retrieve memories from specific participants or sessions when needed.
|
||||
|
||||
5. **Async Processing**: Use `async_mode=True` for large group conversations to improve performance.
|
||||
5. **Async Processing**: Memory additions are processed asynchronously by default, which is ideal for large group conversations.
|
||||
|
||||
6. **Search Context**: Leverage the search functionality to find specific information within group chat contexts.
|
||||
|
||||
|
||||
Reference in New Issue
Block a user