User Profiles for AI Agents: The Complete Guide to Personalized AI That Actually Knows Your Users
User Profiles for AI Agents: The Complete Guide to Personalized AI That Actually Knows Your Users
Your AI agent responds the same way to every user—a enterprise CTO gets the same tone as a college freshman, a returning customer the same greeting as a first-time visitor. Without user profiles, your AI is guessing blind. Here's how to fix that.
Building AI agents that feel intelligent requires more than a capable model. True intelligence is contextual—adapting behavior based on who you're interacting with, their history, preferences, and goals. User profiles are the structured representation of this knowledge, and implementing them properly separates generic chatbots from AI that users actually want to keep using.
This guide covers everything you need to know about building user profiles for AI agents: what data to collect, how to structure it, extraction techniques, storage strategies, and practical implementation patterns with code examples.
What Are User Profiles for AI Agents?
A user profile in the context of AI agents is a structured collection of information about a specific user that persists across interactions and influences how the agent behaves. Unlike session state (which tracks the current conversation) or conversation history (which logs what was said), user profiles encode distilled knowledge about who someone is.
Think of the difference like this:
- Conversation history: "The user asked about Python yesterday"
- Session state: "We're currently discussing API authentication"
- User profile: "This is an experienced Python developer who prefers code examples over explanations and values concise responses"
User profiles answer: What does the agent need to know about this user to provide relevant, personalized assistance?
Components of a User Profile
A comprehensive user profile typically includes several categories of information:
Identity and Demographics
- Name, preferred name, pronouns
- Role (developer, manager, end-user)
- Organization or team context
- Geographic location and timezone
Preferences and Behavioral Patterns
- Communication style preferences (formal/casual, detailed/concise)
- Topic interests and domains of expertise
- Feature usage patterns
- Response format preferences (code-first, explanation-first)
Historical Context
- Previous issues or questions
- Products or services used
- Past recommendations and their outcomes
- Significant milestones or events
Dynamic State
- Current goals or active projects
- Recent interactions summary
- Pending items or follow-ups
- Sentiment trajectory
Inferred Characteristics
- Technical proficiency level
- Decision-making patterns
- Engagement style
- Risk tolerance
Why User Profiles Transform AI Agents
Without user profiles, every interaction starts from zero. Your AI agent:
- Asks the same qualifying questions every session
- Provides generic responses regardless of expertise level
- Can't proactively offer relevant assistance
- Treats loyal customers like strangers
- Wastes tokens re-discovering obvious context
With user profiles, the same agent:
- Skips unnecessary questions and gets to the point
- Adapts explanations to match user expertise
- Proactively surfaces relevant information or opportunities
- Remembers ongoing projects and can resume context
- Personalizes tone, detail level, and examples
The business impact is measurable. Users spend less time explaining themselves, which reduces friction and improves satisfaction. Agents handle requests more efficiently, reducing costs. Personalized interactions drive higher engagement and retention. For customer support specifically, agent resolution rates improve when the AI knows the customer's history and technical level.
Architectural Patterns for User Profiles
There are several approaches to implementing user profiles, each with tradeoffs around complexity, flexibility, and performance.
Pattern 1: Context Injection (Simple)
The simplest pattern injects user profile data directly into the system prompt or as a prefix to user messages.
def build_system_prompt(base_prompt: str, user_profile: dict) -> str:
"""Inject user profile into the system prompt."""
profile_context = f"""
USER PROFILE:
- Name: {user_profile.get('name', 'Unknown')}
- Role: {user_profile.get('role', 'User')}
- Expertise Level: {user_profile.get('expertise', 'Intermediate')}
- Communication Preference: {user_profile.get('comm_style', 'balanced')}
- Previous Topics: {', '.join(user_profile.get('topics', [])[-5:])}
- Current Goal: {user_profile.get('current_goal', 'Not specified')}
Adapt your responses to match this user's profile. For a {user_profile.get('expertise', 'intermediate')} user,
{'skip basic explanations and focus on advanced details' if user_profile.get('expertise') == 'expert' else 'provide clear explanations with examples'}.
"""
return base_prompt + "\n\n" + profile_context
# Usage
user = {
"name": "Sarah",
"role": "Senior Developer",
"expertise": "expert",
"comm_style": "concise",
"topics": ["authentication", "API design", "performance"],
"current_goal": "Implementing OAuth 2.0 with PKCE"
}
system_prompt = build_system_prompt(BASE_PROMPT, user)
Pros:
- Simple to implement
- Works with any LLM provider
- Easy to understand and debug
- No additional infrastructure needed
Cons:
- Consumes tokens on every request
- Profile size limited by context window
- No automatic learning—manual updates only
- Doesn't scale to complex profiles
Pattern 2: Retrieval-Augmented Profiles
For richer profiles, retrieve relevant profile segments based on the current conversation context.
from openai import OpenAI
import json
client = OpenAI()
def embed_text(text: str) -> list[float]:
"""Get embedding for text using OpenAI."""
response = client.embeddings.create(
model="text-embedding-3-small",
input=text
)
return response.data[0].embedding
def cosine_similarity(a: list[float], b: list[float]) -> float:
"""Calculate cosine similarity between two vectors."""
import math
dot = sum(x * y for x, y in zip(a, b))
norm_a = math.sqrt(sum(x * x for x in a))
norm_b = math.sqrt(sum(y * y for y in b))
return dot / (norm_a * norm_b) if norm_a and norm_b else 0
class UserProfileStore:
def __init__(self, user_id: str):
self.user_id = user_id
self.facts = [] # List of {"text": str, "embedding": list, "category": str, "timestamp": str}
def add_fact(self, text: str, category: str):
"""Add a fact to the user profile."""
embedding = embed_text(text)
self.facts.append({
"text": text,
"embedding": embedding,
"category": category,
"timestamp": datetime.utcnow().isoformat()
})
def retrieve_relevant(self, query: str, top_k: int = 5) -> list[str]:
"""Retrieve facts most relevant to the current query."""
query_embedding = embed_text(query)
scored = []
for fact in self.facts:
score = cosine_similarity(query_embedding, fact["embedding"])
scored.append((score, fact["text"]))
scored.sort(reverse=True)
return [text for score, text in scored[:top_k]]
# Usage
profile = UserProfileStore("user_123")
profile.add_fact("User prefers TypeScript over JavaScript", "preference")
profile.add_fact("Working on a React Native mobile app", "project")
profile.add_fact("Previously had issues with async/await patterns", "history")
profile.add_fact("Timezone is PST, usually active 9am-6pm", "context")
# When user asks about mobile development
relevant = profile.retrieve_relevant("How do I handle async data fetching?")
# Returns facts about async/await issues and React Native project
Pros:
- Only includes relevant profile data in context
- Can handle arbitrarily large profiles
- Naturally prioritizes recent/relevant information
- More token-efficient for complex profiles
Cons:
- Requires embedding infrastructure
- Additional latency for retrieval step
- Need to manage vector storage
- Relevance depends on query quality
Pattern 3: Structured Profile with Schema
Define a formal schema for user profiles and use structured extraction to update them.
from pydantic import BaseModel, Field
from typing import Optional
from datetime import datetime
from enum import Enum
class ExpertiseLevel(str, Enum):
BEGINNER = "beginner"
INTERMEDIATE = "intermediate"
ADVANCED = "advanced"
EXPERT = "expert"
class CommunicationStyle(str, Enum):
FORMAL = "formal"
CASUAL = "casual"
TECHNICAL = "technical"
SIMPLIFIED = "simplified"
class UserProfile(BaseModel):
"""Structured user profile schema."""
user_id: str
# Identity
name: Optional[str] = None
preferred_name: Optional[str] = None
role: Optional[str] = None
organization: Optional[str] = None
timezone: Optional[str] = None
# Expertise
technical_level: ExpertiseLevel = ExpertiseLevel.INTERMEDIATE
domain_expertise: list[str] = Field(default_factory=list)
tools_used: list[str] = Field(default_factory=list)
# Preferences
communication_style: CommunicationStyle = CommunicationStyle.TECHNICAL
response_length_preference: str = "balanced" # "concise", "balanced", "detailed"
prefers_code_examples: bool = True
prefers_analogies: bool = False
# Context
current_projects: list[str] = Field(default_factory=list)
recent_topics: list[str] = Field(default_factory=list)
pain_points: list[str] = Field(default_factory=list)
# Metadata
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
interaction_count: int = 0
def to_context_string(self) -> str:
"""Convert profile to string for injection."""
parts = [f"User: {self.preferred_name or self.name or 'Unknown'}"]
if self.role:
parts.append(f"Role: {self.role}")
if self.technical_level:
parts.append(f"Technical Level: {self.technical_level.value}")
if self.domain_expertise:
parts.append(f"Expertise: {', '.join(self.domain_expertise[:5])}")
if self.current_projects:
parts.append(f"Current Projects: {', '.join(self.current_projects[:3])}")
if self.communication_style:
parts.append(f"Prefers {self.communication_style.value} communication")
if self.prefers_code_examples:
parts.append("Responds well to code examples")
return "\n".join(parts)
# Extraction prompt for updating profiles from conversations
EXTRACTION_PROMPT = """
Analyze this conversation and extract any new information about the user.
Return a JSON object with only the fields that have new or updated information.
Current profile:
{current_profile}
Conversation:
{conversation}
Fields to consider:
- name, preferred_name: If they mention their name
- role: Their job role or position
- organization: Their company or team
- technical_level: beginner, intermediate, advanced, or expert
- domain_expertise: Areas they demonstrate knowledge in
- tools_used: Technologies they mention using
- communication_style: formal, casual, technical, or simplified
- current_projects: What they're actively working on
- pain_points: Problems or frustrations they mention
Return valid JSON only. Only include fields with new information.
"""
Pros:
- Consistent, predictable structure
- Easy to query and update specific fields
- Type safety and validation
- Clear contract between systems
Cons:
- May not capture nuanced information
- Requires upfront schema design
- Updates need careful handling to avoid overwrites
- Schema migrations as requirements change
Pattern 4: Hybrid Proxy Architecture
The most sophisticated pattern combines structured profiles with automatic extraction and injection, often implemented as a proxy layer.
from dataclasses import dataclass, field
from typing import Callable
import asyncio
@dataclass
class UserProfileProxy:
"""Proxy that automatically enriches LLM requests with user profile."""
user_id: str
profile_store: ProfileStore
llm_client: LLMClient
extraction_enabled: bool = True
# Hooks for customization
pre_request_hook: Callable | None = None
post_response_hook: Callable | None = None
async def chat(self, messages: list[dict], **kwargs) -> dict:
"""
Send a chat request with automatic profile injection and extraction.
"""
# 1. Load current profile
profile = await self.profile_store.get(self.user_id)
# 2. Retrieve relevant memories based on conversation
last_user_message = next(
(m["content"] for m in reversed(messages) if m["role"] == "user"),
""
)
relevant_memories = await self.profile_store.retrieve_memories(
self.user_id,
last_user_message,
limit=5
)
# 3. Build enriched system message
profile_context = self._build_profile_context(profile, relevant_memories)
enriched_messages = self._inject_profile(messages, profile_context)
# 4. Optional pre-request hook
if self.pre_request_hook:
enriched_messages = await self.pre_request_hook(enriched_messages, profile)
# 5. Call the LLM
response = await self.llm_client.chat(enriched_messages, **kwargs)
# 6. Extract profile updates from conversation (async, non-blocking)
if self.extraction_enabled:
asyncio.create_task(
self._extract_and_update_profile(messages, response, profile)
)
# 7. Optional post-response hook
if self.post_response_hook:
response = await self.post_response_hook(response, profile)
return response
def _build_profile_context(self, profile: UserProfile, memories: list[str]) -> str:
"""Build context string from profile and memories."""
parts = [
"=== USER CONTEXT ===",
profile.to_context_string(),
]
if memories:
parts.append("\nRelevant previous context:")
for memory in memories:
parts.append(f"- {memory}")
parts.append("=== END USER CONTEXT ===")
return "\n".join(parts)
def _inject_profile(self, messages: list[dict], context: str) -> list[dict]:
"""Inject profile context into messages."""
enriched = []
for msg in messages:
if msg["role"] == "system":
enriched.append({
"role": "system",
"content": msg["content"] + "\n\n" + context
})
else:
enriched.append(msg)
return enriched
async def _extract_and_update_profile(
self,
messages: list[dict],
response: dict,
current_profile: UserProfile
):
"""Extract new information from conversation and update profile."""
# This runs in background - doesn't block the response
full_conversation = messages + [{"role": "assistant", "content": response["content"]}]
updates = await self._extract_profile_updates(full_conversation, current_profile)
if updates:
await self.profile_store.update(self.user_id, updates)
This pattern, often called a "context layer" or "personalization proxy," gives you the best of all worlds: automatic profile enrichment, background learning, and clean separation from your application code.
What Data to Collect: Profile Field Reference
Building effective user profiles requires knowing what information actually improves agent interactions. Here's a practical reference:
High-Impact Fields (Collect First)
Technical Proficiency Level
- Effect: Dramatically changes explanation depth
- How to detect: Vocabulary analysis, question complexity, tool mentions
- Update frequency: Rarely changes; validate quarterly
Communication Style Preference
- Effect: Shapes tone, formality, and structure of responses
- How to detect: User's own writing style, explicit preferences, feedback
- Update frequency: Stable once detected
Current Project/Goal Context
- Effect: Enables proactive, relevant assistance
- How to detect: Explicit mentions, recurring topics, file/code context
- Update frequency: Changes frequently; needs regular refresh
Domain Expertise Areas
- Effect: Skip basics, go deep on relevant topics
- How to detect: Demonstrated knowledge, role, questions asked
- Update frequency: Grows over time; rarely shrinks
Medium-Impact Fields (Collect When Available)
Preferred Tools and Technologies
- Effect: Examples and recommendations match their stack
- How to detect: Mentions in conversation, code snippets, errors
- Update frequency: Evolves with projects
Past Issues and Resolutions
- Effect: Avoid recommending failed approaches, learn from history
- How to detect: Explicit tracking, conversation mining
- Update frequency: Append-only; grows continuously
Timezone and Availability
- Effect: Scheduling, urgency assessment, greeting appropriateness
- How to detect: Explicit, IP geolocation, activity patterns
- Update frequency: Occasionally changes
Team/Organization Context
- Effect: Understand constraints, standards, and collaboration needs
- How to detect: Explicit mention, email domain, shared contexts
- Update frequency: Stable, occasional role changes
Lower-Impact Fields (Nice to Have)
Name and Preferred Address
- Effect: More personal interaction
- How to detect: Self-introduction, signature patterns
- Update frequency: Rarely changes
Response Format Preferences
- Effect: Bullet points vs prose, code-first vs explanation-first
- How to detect: Explicit feedback, interaction patterns
- Update frequency: Stable once learned
Sentiment History
- Effect: Detect frustration patterns, adjust approach
- How to detect: Sentiment analysis on messages
- Update frequency: Continuous tracking
Automatic Profile Extraction Techniques
Manually building user profiles doesn't scale. Here are techniques for automatic extraction:
Pattern 1: Post-Conversation Extraction
After each conversation, extract potential profile updates:
EXTRACTION_SYSTEM_PROMPT = """
You analyze conversations to extract user profile information.
Given a conversation, identify any new facts about the user that should be remembered.
Return a JSON array of facts. Each fact should have:
- "category": one of ["preference", "expertise", "project", "background", "tool", "pain_point", "style"]
- "content": the fact to remember (short, specific statement)
- "confidence": float 0-1 indicating how certain you are
Only extract information explicitly stated or strongly implied.
Do not infer or guess. If uncertain, use low confidence.
Examples of good extractions:
- {"category": "expertise", "content": "Has 5+ years experience with PostgreSQL", "confidence": 0.9}
- {"category": "project", "content": "Building a mobile app for fitness tracking", "confidence": 0.95}
- {"category": "preference", "content": "Prefers detailed explanations with examples", "confidence": 0.7}
Examples of bad extractions (too vague or guessed):
- {"category": "expertise", "content": "Seems technical", "confidence": 0.5}
- {"category": "background", "content": "Probably works at a startup", "confidence": 0.3}
"""
async def extract_profile_facts(conversation: list[dict], client: OpenAI) -> list[dict]:
"""Extract profile facts from a conversation."""
conv_text = "\n".join(
f"{m['role'].upper()}: {m['content']}"
for m in conversation
)
response = await client.chat.completions.create(
model="gpt-4o-mini", # Smaller model sufficient for extraction
messages=[
{"role": "system", "content": EXTRACTION_SYSTEM_PROMPT},
{"role": "user", "content": f"Conversation:\n{conv_text}"}
],
response_format={"type": "json_object"},
temperature=0
)
try:
result = json.loads(response.choices[0].message.content)
facts = result.get("facts", [])
# Filter low confidence
return [f for f in facts if f.get("confidence", 0) >= 0.6]
except json.JSONDecodeError:
return []
Pattern 2: Real-Time Signal Detection
Detect profile signals during conversation without separate extraction:
class ProfileSignalDetector:
"""Detect profile-relevant signals in real-time."""
# Patterns that indicate specific profile traits
PATTERNS = {
"expertise_high": [
r"I've been (working with|using) .+ for (\d+)\+ years",
r"In my experience (implementing|building|architecting)",
r"The nuance here is",
r"A common pitfall",
],
"expertise_low": [
r"I'm (new to|learning|just starting)",
r"What (does|is) .+ mean",
r"Can you explain .+ (simply|like I'm)",
r"I don't understand",
],
"prefers_concise": [
r"(TL;DR|TLDR|in short|briefly)",
r"Just (tell me|give me) (the answer|how to)",
r"Skip the (explanation|details)",
],
"prefers_detailed": [
r"Can you (explain|elaborate|go deeper)",
r"Why (does|is|would)",
r"What's the reasoning",
r"Help me understand",
],
}
def detect(self, message: str) -> list[tuple[str, float]]:
"""Detect profile signals in a message. Returns [(signal, confidence), ...]"""
signals = []
for signal_type, patterns in self.PATTERNS.items():
for pattern in patterns:
if re.search(pattern, message, re.IGNORECASE):
signals.append((signal_type, 0.7))
break
return signals
def update_profile(self, profile: UserProfile, signals: list[tuple[str, float]]):
"""Update profile based on detected signals."""
for signal, confidence in signals:
if signal == "expertise_high" and confidence > 0.6:
# Only upgrade, never downgrade from single signal
if profile.technical_level in [ExpertiseLevel.BEGINNER, ExpertiseLevel.INTERMEDIATE]:
profile.technical_level = ExpertiseLevel.ADVANCED
elif signal == "prefers_concise":
profile.response_length_preference = "concise"
elif signal == "prefers_detailed":
profile.response_length_preference = "detailed"
Pattern 3: Summarization for Long-Term Memory
Periodically summarize accumulated interactions into profile updates:
SUMMARIZE_PROMPT = """
Review these recent interactions with a user and update their profile.
Current profile:
{current_profile}
Recent interactions (last 2 weeks):
{interactions}
Based on these interactions, provide an updated profile that:
1. Preserves existing accurate information
2. Adds new facts learned from interactions
3. Updates any information that has changed
4. Removes outdated or contradicted information
Return the complete updated profile as JSON matching the schema.
"""
async def summarize_into_profile(
profile: UserProfile,
recent_interactions: list[dict],
client: OpenAI
) -> UserProfile:
"""Periodically summarize interactions into profile updates."""
interactions_text = "\n---\n".join(
f"Date: {i['date']}\n{i['summary']}"
for i in recent_interactions
)
response = await client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": SUMMARIZE_PROMPT.format(
current_profile=profile.model_dump_json(indent=2),
interactions=interactions_text
)}
],
response_format={"type": "json_object"},
temperature=0
)
updated_data = json.loads(response.choices[0].message.content)
return UserProfile(**updated_data)
Storage Strategies for User Profiles
Where and how you store profiles depends on your scale and query patterns.
Option 1: Relational Database (PostgreSQL)
Best for: Structured queries, strong consistency, moderate scale
CREATE TABLE user_profiles (
user_id TEXT PRIMARY KEY,
name TEXT,
preferred_name TEXT,
role TEXT,
organization TEXT,
timezone TEXT,
technical_level TEXT DEFAULT 'intermediate',
communication_style TEXT DEFAULT 'technical',
response_length_preference TEXT DEFAULT 'balanced',
prefers_code_examples BOOLEAN DEFAULT true,
domain_expertise TEXT[] DEFAULT '{}',
tools_used TEXT[] DEFAULT '{}',
current_projects TEXT[] DEFAULT '{}',
recent_topics TEXT[] DEFAULT '{}',
pain_points TEXT[] DEFAULT '{}',
created_at TIMESTAMPTZ DEFAULT NOW(),
updated_at TIMESTAMPTZ DEFAULT NOW(),
interaction_count INTEGER DEFAULT 0
);
-- For flexible key-value facts
CREATE TABLE user_facts (
id SERIAL PRIMARY KEY,
user_id TEXT REFERENCES user_profiles(user_id),
category TEXT NOT NULL,
content TEXT NOT NULL,
confidence REAL DEFAULT 1.0,
source TEXT, -- 'explicit', 'extracted', 'inferred'
created_at TIMESTAMPTZ DEFAULT NOW(),
expires_at TIMESTAMPTZ -- for temporary facts
);
CREATE INDEX idx_user_facts_user_category ON user_facts(user_id, category);
-- For vector search on memories (with pgvector)
CREATE TABLE user_memories (
id SERIAL PRIMARY KEY,
user_id TEXT REFERENCES user_profiles(user_id),
content TEXT NOT NULL,
embedding vector(1536),
memory_type TEXT, -- 'conversation', 'fact', 'preference'
importance REAL DEFAULT 0.5,
created_at TIMESTAMPTZ DEFAULT NOW(),
last_accessed TIMESTAMPTZ
);
CREATE INDEX idx_user_memories_embedding ON user_memories
USING ivfflat (embedding vector_cosine_ops);
Option 2: Document Database (MongoDB)
Best for: Flexible schemas, rapid iteration, nested data
# MongoDB schema (implicit, but documented)
user_profile_schema = {
"_id": "user_123", # user_id
"identity": {
"name": "Sarah Chen",
"preferred_name": "Sarah",
"role": "Senior Developer",
"organization": "Acme Corp",
"timezone": "America/Los_Angeles"
},
"expertise": {
"level": "advanced",
"domains": ["backend", "databases", "API design"],
"tools": ["Python", "PostgreSQL", "FastAPI", "Docker"],
"years_experience": 8
},
"preferences": {
"communication_style": "technical",
"response_length": "concise",
"prefers_code_examples": True,
"prefers_analogies": False,
"format_preferences": {
"code_language": "python",
"use_type_hints": True
}
},
"context": {
"current_projects": [
{"name": "API Migration", "started": "2024-01-15", "status": "active"}
],
"recent_topics": ["rate limiting", "caching", "OAuth"],
"pain_points": ["legacy system integration", "documentation"]
},
"memories": [
{
"content": "Had issues with async connection pooling last month",
"category": "history",
"timestamp": "2024-02-01T10:30:00Z",
"importance": 0.7
}
],
"metadata": {
"created_at": "2024-01-01T00:00:00Z",
"updated_at": "2024-02-15T14:30:00Z",
"interaction_count": 47,
"last_interaction": "2024-02-15T14:30:00Z"
}
}
Option 3: Hybrid with Specialized Stores
Best for: Production systems at scale
┌─────────────────────────────────────────────────────────────┐
│ Profile Access Layer │
└────────────────────────────┬────────────────────────────────┘
│
┌───────────────────┼───────────────────┐
│ │ │
▼ ▼ ▼
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ PostgreSQL │ │ Redis │ │ Pinecone │
│ │ │ │ │ │
│ Core profile │ │ Session cache │ │ Memory vectors │
│ Structured data │ │ Hot profile │ │ Semantic search │
│ Transactions │ │ Real-time state │ │ Similarity │
└─────────────────┘ └─────────────────┘ └─────────────────┘
Dytto: Purpose-Built User Profiles for AI Agents
While you can build user profile infrastructure from scratch, Dytto provides a purpose-built solution for AI agent personalization.
How Dytto Approaches User Profiles
Dytto functions as a context and memory layer specifically designed for AI applications. Rather than bolting memory onto existing systems, it's built from the ground up to solve the user profile problem.
Automatic Profile Building
Dytto observes interactions and automatically extracts user profile information without manual tagging or schema definition:
import requests
DYTTO_API_KEY = "your_api_key"
DYTTO_URL = "https://api.dytto.app"
# Report an observation about the user
def observe(user_id: str, content: str, context: dict = None):
"""Send an observation to Dytto for profile building."""
response = requests.post(
f"{DYTTO_URL}/observe",
headers={"Authorization": f"Bearer {DYTTO_API_KEY}"},
json={
"user_id": user_id,
"content": content,
"context": context or {},
"timestamp": datetime.utcnow().isoformat()
}
)
return response.json()
# After a conversation where user mentions their role
observe(
user_id="user_123",
content="User mentioned they're a senior engineer at a fintech startup working on payment processing",
context={"source": "chat", "session_id": "sess_abc"}
)
Structured Context Retrieval
When you need to personalize an AI interaction, retrieve the user's context:
def get_user_context(user_id: str) -> dict:
"""Retrieve user context from Dytto."""
response = requests.get(
f"{DYTTO_URL}/context/{user_id}",
headers={"Authorization": f"Bearer {DYTTO_API_KEY}"}
)
return response.json()
# Returns structured context ready for injection
context = get_user_context("user_123")
# {
# "summary": "Senior engineer at fintech startup, working on payments...",
# "traits": {
# "role": {"value": "Senior Engineer", "confidence": 0.9},
# "industry": {"value": "Fintech", "confidence": 0.85},
# "expertise_areas": ["payments", "backend", "API design"]
# },
# "recent_topics": ["PCI compliance", "webhook reliability"],
# "preferences": {
# "technical_level": "advanced",
# "response_style": "concise"
# }
# }
Semantic Memory Search
Find relevant memories based on the current conversation:
def search_memories(user_id: str, query: str, limit: int = 5) -> list:
"""Search user's memories semantically."""
response = requests.post(
f"{DYTTO_URL}/search",
headers={"Authorization": f"Bearer {DYTTO_API_KEY}"},
json={
"user_id": user_id,
"query": query,
"limit": limit
}
)
return response.json()["results"]
# When user asks about webhooks
memories = search_memories("user_123", "webhook implementation problems")
# Returns relevant past context about their webhook issues
Why Use a Dedicated Context Layer
Building user profiles in-house is possible but involves significant complexity:
-
Schema evolution: User profile needs change over time. Managing migrations and backward compatibility is ongoing work.
-
Extraction accuracy: Getting reliable profile extraction requires tuning prompts, handling edge cases, and validating outputs.
-
Storage infrastructure: You need databases, vector stores, caching layers, and the expertise to operate them.
-
Privacy and compliance: User data requires careful handling—encryption, access controls, deletion capabilities.
-
Retrieval optimization: Efficiently retrieving relevant context requires indexing strategies and query optimization.
A purpose-built solution like Dytto handles these concerns so you can focus on your application logic rather than infrastructure.
Best Practices for User Profile Implementation
Based on production experience, here are practices that separate good profile systems from great ones:
Start Simple, Add Complexity Incrementally
Don't build the full architecture upfront. Start with:
- Basic key-value profile fields (name, role, expertise level)
- Manual updates only
- Simple context injection
Then add:
- Automatic extraction
- Vector memories
- Retrieval-based context selection
Validate Before Storing
Not everything extracted should be stored. Implement validation:
def should_store_fact(fact: dict, existing_profile: UserProfile) -> bool:
"""Decide if an extracted fact should be stored."""
# Confidence threshold
if fact.get("confidence", 0) < 0.6:
return False
# Don't store contradictions without review
if contradicts_existing(fact, existing_profile):
flag_for_review(fact)
return False
# Don't store extremely common facts
if is_generic(fact["content"]):
return False
# Don't duplicate existing knowledge
if similar_fact_exists(fact, existing_profile):
return False
return True
Implement Decay and Expiration
User profiles go stale. Implement mechanisms to handle this:
def get_weighted_profile_data(profile: UserProfile, current_date: date) -> dict:
"""Weight profile data by recency."""
weights = {}
for fact in profile.facts:
age_days = (current_date - fact.created_at.date()).days
# Recent facts weighted higher
if age_days < 7:
weight = 1.0
elif age_days < 30:
weight = 0.8
elif age_days < 90:
weight = 0.5
else:
weight = 0.2
# Some categories decay slower
if fact.category in ["preference", "background"]:
weight = min(1.0, weight * 1.5)
weights[fact.id] = weight
return weights
Give Users Control
Users should be able to view and modify their profiles:
- Provide a profile viewer showing what you know
- Allow corrections and deletions
- Support explicit preference setting
- Offer an "incognito" mode that doesn't update profiles
Separate Extraction from Application
Run profile extraction asynchronously, not in the request path:
# Good: Non-blocking extraction
async def handle_message(message):
response = await generate_response(message)
# Fire and forget - don't slow down the response
asyncio.create_task(extract_and_update_profile(message, response))
return response
# Bad: Blocking extraction
async def handle_message(message):
response = await generate_response(message)
# This slows down every interaction
await extract_and_update_profile(message, response)
return response
Measuring Profile Effectiveness
How do you know if your profiles are working? Track these metrics:
Personalization Relevance Score
- Sample interactions, rate how well responses matched user context
- Target: 4+/5 on context appropriateness
Profile Coverage
- Percentage of active users with populated profiles
- Target: >80% of users with 30+ days activity have core fields populated
Extraction Accuracy
- Sample extracted facts, verify correctness
- Target: >90% accuracy on high-confidence extractions
Context Utilization
- Track how often retrieved context is used in responses
- Target: >70% of responses reference profile data when relevant
User Satisfaction Delta
- Compare satisfaction scores: personalized vs generic experiences
- Target: Measurable improvement in NPS or satisfaction scores
Conclusion
User profiles transform AI agents from stateless responders into intelligent assistants that know their users. The investment in proper profile infrastructure pays dividends in user satisfaction, efficiency, and differentiation.
Start with the basics: capture expertise level, communication preferences, and current context. Use simple injection before building complex retrieval systems. Validate and expire data to maintain quality. Give users visibility and control.
Whether you build custom infrastructure or use a purpose-built solution like Dytto, the outcome is the same: AI that actually understands who it's talking to.
Building AI agents that need user profiles? Dytto provides the context and memory layer purpose-built for AI personalization. Check out the API documentation to get started.