> ## Documentation Index
> Fetch the complete documentation index at: https://docs.hydradb.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Build your own Glean with HydraDB
> Learn how to build a comprehensive workplace search and AI assistant platform using HydraDB APIs. This guide covers data ingestion, retrieval, and app-layer answer generation across multiple data sources.
This guide will walk you through building an extremely powerful workplace search and AI assistant platform that rivals Glean using HydraDB APIs. You'll learn how to create a unified retrieval experience across multiple data sources and generate answers in your application layer.
> **Note**: All code in this guide uses the official HydraDB Python SDK. Base URL: `https://api.hydradb.com`. Get your API key at [app.hydradb.com](https://app.hydradb.com).
## Prerequisites
**Required knowledge**: Python basics, REST APIs, environment variables\
**Required tools**:
* HydraDB API key
* Python 3.11 or 3.12 (`python --version`)
* `pip install hydradb-sdk`
## What You'll Build
By the end of this cookbook, you'll be able to:
* Ingest documents from multiple data sources (Slack, email, Google Drive, Jira) into a unified HydraDB knowledge base
* Run natural language workplace search across all sources with a single `full_recall` call
* Personalize search results per user by storing and retrieving AI memories
* Generate grounded AI answers from retrieved context using any LLM
## Overview
A Glean-like application typically includes these core features:
* **Universal Search**: Search across multiple data sources (documents, emails, chats, etc.)
* **Retrieval-Assisted Answers**: Generate intelligent answers from retrieved company knowledge
* **AI Memories for User Preferences**: Remember and adapt to individual user preferences, search patterns, and behavioral patterns
* **Data Ingestion**: Connect to various apps and services
* **Knowledge Graph**: Build connections between information
* **Security & Access Control**: Role-based permissions and data isolation
## Architecture Overview
```mermaid theme={"dark"}
graph TD
A["Frontend UI • Search UI • Chat Interface • Results View"]
B["Backend API • Data Sync • Auth/ACL • App Connectors"]
C["HydraDB APIs • Retrieval Engine • Document Index • Memory Store"]
D["Data Sources • Google apps • Slack • Notion • Jira"]
E["App Connectors for Fetching Data
• Composio • Vanilla APIs • Webhooks • Scheduled Jobs"]
F["Retrieval Layer • HydraDB Memory • User Sessions • Metadata Store"]
A <--> B
B <--> C
A --> D
B <--> E
C --> F
```
## Step 1: Data Ingestion Strategy
### 1.1 App Connectors Setup
You'll need to connect to various data sources. Here are recommended approaches:
#### Option A: Using Composio
[Composio](https://composio.dev/) provides pre-built connectors for popular apps:
```javascript theme={"dark"}
// Example: Setting up Composio connector
const composioConfig = {
connectors: [
{
name: 'slack',
config: {
token: process.env.SLACK_BOT_TOKEN,
channels: ['general', 'random', 'project-*']
}
},
{
name: 'gmail',
config: {
credentials: process.env.GMAIL_CREDENTIALS,
labels: ['INBOX', 'SENT', 'IMPORTANT']
}
},
{
name: 'notion',
config: {
token: process.env.NOTION_TOKEN,
databases: ['projects', 'docs', 'meetings']
}
}
]
};
```
#### Option B: Vanilla API Integration
For custom integrations, use the native APIs:
```javascript theme={"dark"}
// Example: Slack API integration
class SlackConnector {
constructor(token) {
this.token = token;
this.client = new WebClient(token);
}
async fetchMessages(channelId, limit = 100) {
const result = await this.client.conversations.history({
channel: channelId,
limit: limit
});
return result.messages.map(msg => ({
id: msg.ts,
text: msg.text,
user: msg.user,
timestamp: msg.ts,
channel: channelId,
type: 'slack_message'
}));
}
async fetchChannels() {
const result = await this.client.conversations.list();
return result.channels;
}
}
// Example: Gmail API integration
class GmailConnector {
constructor(credentials) {
this.gmail = google.gmail({ version: 'v1', auth: credentials });
}
async fetchEmails(query = 'in:inbox', maxResults = 100) {
const response = await this.gmail.users.messages.list({
userId: 'me',
q: query,
maxResults: maxResults
});
const emails = [];
for (const message of response.data.messages) {
const email = await this.gmail.users.messages.get({
userId: 'me',
id: message.id
});
emails.push({
id: email.data.id,
subject: this.getHeader(email.data.payload.headers, 'Subject'),
from: this.getHeader(email.data.payload.headers, 'From'),
body: this.getBody(email.data.payload),
timestamp: email.data.internalDate,
type: 'gmail'
});
}
return emails;
}
}
```
### 1.2 Data Normalization
Normalize every connector record into HydraDB's typed app-source contract. This preserves provider IDs, threads, actors, and relations for app-aware recall:
> **Important**: For optimal performance, limit each batch to a maximum of **20 app sources** per request. Send multiple batch requests with an interval of **1 second** between each request.
```javascript theme={"dark"}
// Typed app-source item for HydraDB app upload
const normalizedData = {
id: "slack_C01_1716213600_000100", // stable HydraDB source ID
tenant_id: "your_tenant_id",
sub_tenant_id: "workspace",
kind: "message", // email | message | ticket | knowledge_base | comment | custom
provider: "slack", // slack | gmail | jira | notion | salesforce | ...
external_id: "1716213600.000100", // provider's stable item ID
fields: {
kind: "message",
body: "Main content text",
author: "user@company.com",
thread_id: "1716213600.000100",
parent_id: undefined, // set to the root ts only for replies
created_at: "2024-01-01T00:00:00Z",
url: "https://app.com/item/123"
},
metadata: {
container_type: "channel",
container_id: "C01",
container_name: "engineering",
source: "slack"
},
relations: [], // e.g. { predicate: "linked_to", target: { external_id: "AUTH-123", provider: "jira" } }
attachments: [] // include content.text/markdown when you already extracted file text
};
```
### 1.3 Batch Upload to HydraDB
Use HydraDB's batch upload capabilities for efficient data ingestion:
> **Best Practice**: Always verify processing after upload using the `/ingestion/verify_processing` endpoint to ensure your data is properly indexed.
```typescript TypeScript SDK theme={"dark"}
import { HydraDBClient } from "@hydradb/sdk";
const client = new HydraDBClient({ token: process.env.HYDRA_DB_API_KEY! });
// Upload a batch of typed app sources
const uploadBatch = async (sources: any[], tenantId: string, subTenantId = "workspace") => {
const appKnowledge = sources.map(source => ({
...source,
tenant_id: tenantId,
sub_tenant_id: subTenantId
}));
const result = await client.upload.knowledge({
tenant_id: tenantId,
app_knowledge: JSON.stringify(appKnowledge)
});
return result;
};
// Upload with verification — confirm each item is indexed before proceeding
const uploadWithVerification = async (sources: any[], tenantId: string, subTenantId?: string) => {
const uploadResult = await uploadBatch(sources, tenantId, subTenantId);
const sourceIds = (uploadResult.results ?? [])
.map((item: any) => item.source_id)
.filter(Boolean);
if (sourceIds.length) {
for (const sourceId of sourceIds) {
const status = await client.upload.verifyProcessing({
tenant_id: tenantId,
file_ids: [sourceId]
});
if (status.indexing_status === "errored") {
throw new Error(`Processing failed for source ${sourceId}`);
}
}
}
return uploadResult;
};
```
```python Python SDK theme={"dark"}
import os
import json
from hydra_db import HydraDB
client = HydraDB(token=os.environ["HYDRA_DB_API_KEY"])
# Upload a batch of typed app sources
def upload_batch(sources: list, tenant_id: str, sub_tenant_id: str = "workspace"):
sub_tenant_id = sub_tenant_id or "workspace"
app_knowledge = [
{**source, "tenant_id": tenant_id, "sub_tenant_id": sub_tenant_id}
for source in sources
]
result = client.upload.knowledge(
tenant_id=tenant_id,
app_knowledge=json.dumps(app_knowledge)
)
return result
# Upload with verification — confirm each item is indexed before proceeding
def upload_with_verification(sources: list, tenant_id: str, sub_tenant_id: str = None):
upload_result = upload_batch(sources, tenant_id, sub_tenant_id)
if upload_result.results:
for item in upload_result.results:
source_id = item.source_id
status = client.upload.verify_processing(
tenant_id=tenant_id,
file_ids=[source_id]
)
items = status.statuses or []
if items and items[0].indexing_status == "errored":
raise Exception(f"Processing failed for source {source_id}")
return upload_result
```
## Step 2: Search and Answer Generation
### 2.1 Universal Search Interface
Create a search interface that queries across all data sources:
> **Note**: App-aware search requires `search_apps: true`. If you need hard filters, mirror stable scope values into `metadata` during ingestion (for example `source: "slack"` or `container_id: "C01"`) and query them with `metadata_filters`.
```typescript TypeScript SDK theme={"dark"}
import { HydraDBClient } from "@hydradb/sdk";
const client = new HydraDBClient({ token: process.env.HYDRA_DB_API_KEY! });
interface SearchOptions {
sub_tenant_id?: string;
max_results?: number;
mode?: "fast" | "thinking";
metadata_filters?: Record;
}
const search = async (query: string, tenantId: string, options: SearchOptions = {}) => {
const {
sub_tenant_id,
max_results = 10,
mode = "thinking",
metadata_filters,
} = options;
return await client.recall.fullRecall({
query,
tenant_id: tenantId,
sub_tenant_id,
max_results,
mode,
search_apps: true,
alpha: 0.5, // Balance semantic vs keyword search (0.0 to 1.0)
recency_bias: 0.3, // Recency preference (0.0 to 1.0)
...(metadata_filters && { metadata_filters }),
});
};
// Filter by provider/source when you mirrored it into metadata at ingestion
const searchByProvider = (query: string, tenantId: string, provider: string) =>
search(`${provider} ${query}`, tenantId, { metadata_filters: { source: provider } });
// Filter by container/channel/project when stored in metadata
const searchByContainer = (query: string, tenantId: string, containerId: string) =>
search(query, tenantId, { metadata_filters: { container_id: containerId } });
```
```python Python SDK theme={"dark"}
import os
from hydra_db import HydraDB
client = HydraDB(token=os.environ["HYDRA_DB_API_KEY"])
def search(query: str, tenant_id: str, sub_tenant_id: str = None,
max_results: int = 10, mode: str = "thinking",
metadata_filters: dict = None):
return client.recall.full_recall(
query=query,
tenant_id=tenant_id,
sub_tenant_id=sub_tenant_id,
max_results=max_results,
mode=mode,
search_apps=True,
alpha=0.5, # Balance semantic vs keyword search (0.0 to 1.0)
recency_bias=0.3, # Recency preference (0.0 to 1.0)
**({"metadata_filters": metadata_filters} if metadata_filters else {}),
)
# Filter by provider/source when you mirrored it into metadata at ingestion
def search_by_provider(query: str, tenant_id: str, provider: str):
return search(f"{provider} {query}", tenant_id, metadata_filters={"source": provider})
# Filter by container/channel/project when stored in metadata
def search_by_container(query: str, tenant_id: str, container_id: str):
return search(query, tenant_id, metadata_filters={"container_id": container_id})
```
### 2.2 Advanced Search Features
Implement advanced search capabilities:
> **Advanced Features**:
>
> * `mode`: Use `"thinking"` for multi-query retrieval with reranking, or `"fast"` for single-query retrieval
> * `alpha`: Controls semantic vs keyword matching (0.0-1.0, or `"auto"`)
> * `recency_bias`: Prioritizes recent content (0.0-1.0)
```typescript TypeScript SDK theme={"dark"}
import { HydraDBClient } from "@hydradb/sdk";
const client = new HydraDBClient({ token: process.env.HYDRA_DB_API_KEY! });
// Search with optional metadata filters for provider/container scopes
const searchWithFilters = async (
query: string,
tenantId: string,
filters: { source?: string; containerId?: string } = {}
) => {
const metadata_filters: Record = {};
if (filters.source) metadata_filters.source = filters.source;
if (filters.containerId) metadata_filters.container_id = filters.containerId;
return await client.recall.fullRecall({
query,
tenant_id: tenantId,
max_results: 10,
mode: "thinking",
search_apps: true,
alpha: 0.5,
recency_bias: 0.3,
...(Object.keys(metadata_filters).length > 0 && { metadata_filters })
});
};
// Guide retrieval with additional context — prepend context to the query string
const searchWithContext = async (query: string, tenantId: string, context: string) =>
client.recall.fullRecall({
query: context ? `${context}\n\n${query}` : query,
tenant_id: tenantId,
max_results: 10,
mode: "thinking",
search_apps: true,
alpha: 0.5,
recency_bias: 0.3,
});
// Conversational search — fold prior conversation turns into the query
const conversationalSearch = async (
query: string,
tenantId: string,
conversationHistory: object[] = []
) =>
client.recall.fullRecall({
query: conversationHistory.length
? `Previous conversation context: ${JSON.stringify(conversationHistory)}\n\n${query}`
: query,
tenant_id: tenantId,
max_results: 10,
mode: "thinking",
search_apps: true,
alpha: 0.5,
recency_bias: 0.3,
});
```
```python Python SDK theme={"dark"}
import os
import json
from hydra_db import HydraDB
client = HydraDB(token=os.environ["HYDRA_DB_API_KEY"])
# Search with optional metadata filters for provider/container scopes
def search_with_filters(query: str, tenant_id: str, source: str = None, container_id: str = None):
metadata_filters = {}
if source:
metadata_filters["source"] = source
if container_id:
metadata_filters["container_id"] = container_id
return client.recall.full_recall(
query=query,
tenant_id=tenant_id,
max_results=10,
mode="thinking",
search_apps=True,
alpha=0.5,
recency_bias=0.3,
**({"metadata_filters": metadata_filters} if metadata_filters else {})
)
# Guide retrieval with additional context — prepend context to the query string
def search_with_context(query: str, tenant_id: str, context: str):
return client.recall.full_recall(
query=f"{context}\n\n{query}" if context else query,
tenant_id=tenant_id,
max_results=10,
mode="thinking",
search_apps=True,
alpha=0.5,
recency_bias=0.3,
)
# Conversational search — fold prior conversation turns into the query
def conversational_search(query: str, tenant_id: str, conversation_history: list = None):
history = conversation_history or []
enriched_query = (
f"Previous conversation context: {json.dumps(history)}\n\n{query}"
if history else query
)
return client.recall.full_recall(
query=enriched_query,
tenant_id=tenant_id,
max_results=10,
mode="thinking",
search_apps=True,
alpha=0.5,
recency_bias=0.3,
)
```
### 2.3 AI Memories and User Preferences
One of the most powerful features of building a Glean-like application with HydraDB is leveraging **AI Memories** to create truly personalized experiences. HydraDB automatically manages AI memories using `sub_tenant_id` for user-level isolation. This allows your application to remember user preferences, past interactions, and behavioral patterns, making every search and interaction more relevant and efficient.
#### Understanding AI Memories
HydraDB's AI memories are dynamic, user-specific profiles that evolve over time. They capture not just what users say, but their intentions, preferences, and unique behaviors. HydraDB automatically manages these memories using `sub_tenant_id` for user-level isolation. This enables your Glean clone to:
* **Remember User Preferences**: Format preferences, source preferences, search patterns
* **Understand Intent**: Learn what types of information users typically seek
* **Adapt Responses**: Tailor answers based on past interactions
* **Anticipate Needs**: Suggest relevant information before users ask
#### Implementing AI Memories in Your Search
```typescript TypeScript SDK theme={"dark"}
import { HydraDBClient } from "@hydradb/sdk";
const client = new HydraDBClient({ token: process.env.HYDRA_DB_API_KEY! });
// In-memory profile store — replace with your own database in production
const userProfiles = new Map();
const getUserProfile = (userId: string) => {
if (!userProfiles.has(userId)) {
userProfiles.set(userId, {
userId,
preferredMode: "fast",
preferredSourceTypes: [] as string[],
frequentQueries: [] as string[],
preferredFormats: ["bullet_points"],
responseStyle: "concise",
favoriteSources: [] as string[],
searchHistory: [] as object[],
lastInteraction: null as string | null
});
}
return userProfiles.get(userId)!;
};
const buildPersonalizedInstructions = (userProfile: any, query: string): string => {
let instructions = "User preferences: ";
if (userProfile.preferredFormats.includes("bullet_points")) instructions += "Prefer bullet point responses. ";
if (userProfile.responseStyle === "concise") instructions += "Keep responses concise and to the point. ";
if (userProfile.favoriteSources.length > 0) instructions += `User frequently uses sources: ${userProfile.favoriteSources.join(", ")}. `;
if (userProfile.frequentQueries.length > 0) instructions += `User often searches for: ${userProfile.frequentQueries.slice(0, 3).join(", ")}. `;
instructions += `Current query: ${query}`;
return instructions;
};
const saveUserProfile = async (userId: string, profile: any) => {
// Persist to your backend database
console.log(`Saving profile for user ${userId}:`, profile);
};
// Search with personalized query enrichment derived from the user's local profile
const searchWithMemory = async (query: string, tenantId: string, userId: string) => {
const userProfile = getUserProfile(userId);
const enrichedQuery = `${buildPersonalizedInstructions(userProfile, query)}\n\n${query}`;
const searchResults = await client.recall.fullRecall({
query: enrichedQuery,
tenant_id: tenantId,
sub_tenant_id: userId,
max_results: 10,
mode: userProfile.preferredMode || "thinking",
search_apps: true,
alpha: 0.5,
recency_bias: 0.3,
...(userProfile.preferredSourceTypes?.length > 0 && {
metadata_filters: { source: userProfile.preferredSourceTypes[0] }
})
});
// Update local profile history
userProfile.searchHistory.push({ query, timestamp: new Date().toISOString(), resultCount: searchResults.chunks?.length || 0 });
if (userProfile.searchHistory.length > 50) userProfile.searchHistory = userProfile.searchHistory.slice(-50);
const queryLower = query.toLowerCase();
if (!userProfile.frequentQueries.some((q: string) => q.toLowerCase().includes(queryLower))) {
userProfile.frequentQueries = [query, ...userProfile.frequentQueries].slice(0, 10);
}
if (searchResults.chunks) {
for (const chunk of searchResults.chunks) {
if (chunk.source && !userProfile.favoriteSources.includes(chunk.source)) {
userProfile.favoriteSources.push(chunk.source);
}
}
userProfile.favoriteSources = userProfile.favoriteSources.slice(0, 5);
}
userProfile.lastInteraction = new Date().toISOString();
await saveUserProfile(userId, userProfile);
return searchResults;
};
```
```python Python SDK theme={"dark"}
import os
from datetime import datetime
from hydra_db import HydraDB
client = HydraDB(token=os.environ["HYDRA_DB_API_KEY"])
# In-memory profile store — replace with your own database in production
user_profiles: dict = {}
def get_user_profile(user_id: str) -> dict:
if user_id not in user_profiles:
user_profiles[user_id] = {
"user_id": user_id,
"preferred_mode": "fast",
"preferred_source_types": [],
"frequent_queries": [],
"preferred_formats": ["bullet_points"],
"response_style": "concise",
"favorite_sources": [],
"search_history": [],
"last_interaction": None
}
return user_profiles[user_id]
def build_personalized_instructions(profile: dict, query: str) -> str:
instructions = "User preferences: "
if "bullet_points" in profile["preferred_formats"]:
instructions += "Prefer bullet point responses. "
if profile["response_style"] == "concise":
instructions += "Keep responses concise and to the point. "
if profile["favorite_sources"]:
instructions += f"User frequently uses sources: {', '.join(profile['favorite_sources'])}. "
if profile["frequent_queries"]:
instructions += f"User often searches for: {', '.join(profile['frequent_queries'][:3])}. "
instructions += f"Current query: {query}"
return instructions
def save_user_profile(user_id: str, profile: dict):
# Persist to your backend database
print(f"Saving profile for user {user_id}:", profile)
# Search with personalized query enrichment derived from the user's local profile
def search_with_memory(query: str, tenant_id: str, user_id: str):
profile = get_user_profile(user_id)
enriched_query = f"{build_personalized_instructions(profile, query)}\n\n{query}"
kwargs = dict(
query=enriched_query,
tenant_id=tenant_id,
sub_tenant_id=user_id,
max_results=10,
mode=profile["preferred_mode"] or "thinking",
search_apps=True,
alpha=0.5,
recency_bias=0.3,
)
if profile["preferred_source_types"]:
kwargs["metadata_filters"] = {"source": profile["preferred_source_types"][0]}
search_results = client.recall.full_recall(**kwargs)
# Update local profile history
profile["search_history"].append({
"query": query,
"timestamp": datetime.utcnow().isoformat(),
"result_count": len(search_results.chunks or [])
})
profile["search_history"] = profile["search_history"][-50:]
if not any(query.lower() in q.lower() for q in profile["frequent_queries"]):
profile["frequent_queries"] = ([query] + profile["frequent_queries"])[:10]
for chunk in (search_results.chunks or []):
if chunk.source_title and chunk.source_title not in profile["favorite_sources"]:
profile["favorite_sources"].append(chunk.source_title)
profile["favorite_sources"] = profile["favorite_sources"][:5]
profile["last_interaction"] = datetime.utcnow().isoformat()
save_user_profile(user_id, profile)
return search_results
```
#### User Preference Learning
```javascript theme={"dark"}
class PreferenceLearner {
constructor() {
this.preferencePatterns = new Map();
}
async learnFromInteraction(userId, interaction) {
const {
query,
selectedResults,
responseFormat,
searchFilters,
timeSpent,
followUpQueries
} = interaction;
const patterns = this.preferencePatterns.get(userId) || {
queryPatterns: [],
formatPreferences: {},
sourcePreferences: {},
timePatterns: [],
filterPreferences: {}
};
// Learn query patterns
this.learnQueryPatterns(patterns, query, followUpQueries);
// Learn format preferences
this.learnFormatPreferences(patterns, responseFormat, selectedResults);
// Learn source preferences
this.learnSourcePreferences(patterns, selectedResults);
// Learn time patterns
this.learnTimePatterns(patterns, timeSpent);
// Learn filter preferences
this.learnFilterPreferences(patterns, searchFilters);
this.preferencePatterns.set(userId, patterns);
}
learnQueryPatterns(patterns, query, followUpQueries) {
// Analyze query complexity, length, and type
const queryAnalysis = {
length: query.length,
complexity: this.analyzeComplexity(query),
type: this.classifyQueryType(query),
hasFilters: query.includes('in:') || query.includes('from:'),
timestamp: new Date().toISOString()
};
patterns.queryPatterns.push(queryAnalysis);
// Keep only recent patterns
if (patterns.queryPatterns.length > 100) {
patterns.queryPatterns = patterns.queryPatterns.slice(-100);
}
}
learnFormatPreferences(patterns, format, selectedResults) {
if (!patterns.formatPreferences[format]) {
patterns.formatPreferences[format] = 0;
}
patterns.formatPreferences[format]++;
}
learnSourcePreferences(patterns, selectedResults) {
selectedResults.forEach(result => {
const sourceType = result.source;
if (!patterns.sourcePreferences[sourceType]) {
patterns.sourcePreferences[sourceType] = 0;
}
patterns.sourcePreferences[sourceType]++;
});
}
analyzeComplexity(query) {
const words = query.split(' ').length;
const hasQuotes = query.includes('"');
const hasOperators = /AND|OR|NOT|in:|from:|to:/.test(query);
let complexity = 'simple';
if (words > 5 || hasQuotes || hasOperators) complexity = 'complex';
if (words > 10 || (hasQuotes && hasOperators)) complexity = 'advanced';
return complexity;
}
classifyQueryType(query) {
if (query.includes('how to') || query.includes('steps')) return 'how-to';
if (query.includes('what is') || query.includes('define')) return 'definition';
if (query.includes('when') || query.includes('schedule')) return 'temporal';
if (query.includes('who') || query.includes('contact')) return 'person';
if (query.includes('where') || query.includes('location')) return 'location';
return 'general';
}
}
```
#### Memory-Enhanced Search Interface
```javascript theme={"dark"}
const MemoryEnhancedSearch = ({ userId }) => {
const [query, setQuery] = useState('');
const [results, setResults] = useState(null);
const [userPreferences, setUserPreferences] = useState(null);
const [suggestions, setSuggestions] = useState([]);
const searchClient = new PersonalizedSearch(API_KEY, TENANT_ID);
const preferenceLearner = new PreferenceLearner();
useEffect(() => {
// Load user preferences on component mount
loadUserPreferences();
}, [userId]);
const loadUserPreferences = async () => {
const profile = await searchClient.getUserProfile(userId);
setUserPreferences(profile);
// Generate search suggestions based on user's history
const suggestions = generateSuggestions(profile);
setSuggestions(suggestions);
};
const generateSuggestions = (profile) => {
const suggestions = [];
// Suggest based on frequent queries
if (profile.frequentQueries.length > 0) {
suggestions.push({
type: 'frequent',
text: profile.frequentQueries[0],
label: 'Frequently searched'
});
}
// Suggest based on recent searches
if (profile.searchHistory.length > 0) {
const recentSearches = profile.searchHistory
.slice(-3)
.map(h => h.query);
recentSearches.forEach(query => {
suggestions.push({
type: 'recent',
text: query,
label: 'Recent search'
});
});
}
return suggestions;
};
const handleSearch = async () => {
const startTime = Date.now();
try {
const searchResults = await searchClient.searchWithMemory(query, userId);
setResults(searchResults);
// Learn from this interaction
const interaction = {
query,
selectedResults: [], // Will be populated when user clicks results
responseFormat: searchResults.format || 'default',
searchFilters: {},
timeSpent: Date.now() - startTime,
followUpQueries: []
};
await preferenceLearner.learnFromInteraction(userId, interaction);
} catch (error) {
console.error('Search failed:', error);
}
};
const handleResultClick = async (result) => {
// Update user preferences when they click on results
const profile = await searchClient.getUserProfile(userId);
// Mark this source type as preferred
if (result.source && !profile.preferredSourceTypes.includes(result.source)) {
profile.preferredSourceTypes.push(result.source);
await searchClient.saveUserProfile(userId, profile);
}
};
return (
setQuery(e.target.value)}
placeholder="Search with your preferences in mind..."
className="search-input"
/>
{/* Show personalized suggestions */}
{suggestions.length > 0 && (
Based on your preferences:
{suggestions.map((suggestion, index) => (
))}
)}
{/* Show user preferences summary */}
{userPreferences && (
);
};
```
#### Benefits of AI Memories in Your Glean Clone
1. **Personalized Search Results**: Users get results tailored to their preferences and past behavior
2. **Faster Information Discovery**: The system learns what sources and formats users prefer
3. **Improved User Experience**: Every interaction feels more personal and relevant
4. **Reduced Cognitive Load**: Users don't need to repeat their preferences or search patterns
5. **Adaptive Learning**: The system continuously improves based on user interactions
6. **Automatic Management**: HydraDB handles memory updates automatically - no manual implementation required
#### Best Practices for AI Memories
* **Respect Privacy**: Always give users control over their data and preferences
* **Transparency**: Show users what preferences are being used and allow them to modify them
* **Graceful Degradation**: Ensure the system works well even without user history
* **Sub-Tenant Isolation**: Use `sub_tenant_id` to isolate user data for personalized experiences
* **Performance**: Cache user profiles to avoid repeated API calls
## Step 3: Frontend Implementation
### 3.1 Search Interface
```javascript theme={"dark"}
// React component example
import React, { useState, useEffect } from 'react';
const GleanSearchInterface = () => {
const [query, setQuery] = useState('');
const [results, setResults] = useState(null);
const [loading, setLoading] = useState(false);
const [filters, setFilters] = useState({
sourceTypes: [],
dateRange: null,
authors: []
});
const searchClient = new AdvancedSearch(API_KEY, TENANT_ID);
const handleSearch = async () => {
setLoading(true);
try {
const searchResults = await searchClient.searchWithFilters(query, filters);
setResults(searchResults);
} catch (error) {
console.error('Search failed:', error);
} finally {
setLoading(false);
}
};
return (
setQuery(e.target.value)}
placeholder="Search across all your work..."
className="search-input"
/>