​
Overview

User management in Julep allows you to create and manage user profiles, enabling personalized experiences and user-specific context in your applications. This guide covers the essential aspects of user management.

​
Creating Users

​
Basic User Creation

Create a new user profile:

Python
# Create a user
user = client.users.create(
    username="john_doe",
    metadata={
        "name": "John Doe",
        "email": "john@example.com",
        "preferences": {
            "language": "en",
            "timezone": "UTC"
        }
    }
)

print(f"Created user: {user.id}")

​
Batch User Creation

Create multiple users efficiently:

Python
# Create multiple users
users = client.users.create_batch([
    {
        "username": "user1",
        "metadata": {
            "name": "User One",
            "email": "user1@example.com"
        }
    },
    {
        "username": "user2",
        "metadata": {
            "name": "User Two",
            "email": "user2@example.com"
        }
    }
])

for user in users:
    print(f"Created user: {user.id}")

​
Managing Users

​
Retrieving Users

Get user information:

Python
# Get user by ID
user = client.users.get(user_id)

# List all users
users = client.users.list()

# Search users
filtered_users = client.users.search(
    query="john",
    metadata_filter={
        "preferences.language": "en"
    }
)

​
Updating Users

Update user profiles:

Python
# Update user metadata
updated_user = client.users.update(
    user_id,
    metadata={
        "preferences": {
            "language": "es",
            "notifications_enabled": True
        }
    }
)

# Patch specific fields
patched_user = client.users.patch(
    user_id,
    metadata={
        "last_login": "2024-01-01T00:00:00Z"
    }
)

​
Deleting Users

Remove user profiles:

Python
# Delete a user
client.users.delete(user_id)

# Batch delete users
client.users.delete_batch(user_ids)

​
User Data Management

​
User Metadata

Structure user metadata effectively:

Python
metadata = {
    "profile": {
        "name": "John Doe",
        "email": "john@example.com",
        "avatar_url": "https://example.com/avatar.jpg"
    },
    "preferences": {
        "language": "en",
        "timezone": "UTC",
        "theme": "dark",
        "notifications": {
            "email": True,
            "push": False
        }
    },
    "settings": {
        "default_model": "gpt-4",
        "max_tokens": 1000,
        "temperature": 0.7
    }
}

user = client.users.create(
    username="john_doe",
    metadata=metadata
)

​
User Groups

Manage user groups:

Python
# Create a group
group = client.groups.create(
    name="premium_users",
    metadata={
        "access_level": "premium",
        "features": ["advanced_tools", "priority_support"]
    }
)

# Add users to group
client.groups.add_users(
    group_id=group.id,
    user_ids=[user1_id, user2_id]
)

# Get group members
members = client.groups.list_users(group.id)

​
User Authentication

​
Token Management

Manage user authentication tokens:

Python
# Create user token
token = client.users.create_token(
    user_id,
    expires_in=3600,  # 1 hour
    metadata={
        "device": "mobile",
        "platform": "ios"
    }
)

# Revoke token
client.users.revoke_token(token.id)

# List user tokens
tokens = client.users.list_tokens(user_id)

​
Session Management

Handle user sessions:

Python
# Create user session
session = client.sessions.create(
    user_id=user.id,
    metadata={
        "device": "web",
        "ip_address": "192.168.1.1"
    }
)

# End session
client.sessions.end(session.id)

# List active sessions
active_sessions = client.sessions.list(
    user_id=user.id,
    status="active"
)

​
Best Practices

  1. User Data Organization

    • Structure metadata consistently
    • Use meaningful field names
    • Include essential user information

  2. Security

    • Implement proper authentication
    • Manage tokens securely
    • Regular security audits

  3. Performance

    • Use batch operations
    • Implement caching
    • Optimize queries

​
Example: Complete User Management

Here’s a comprehensive example of user management:

Python
class UserManager:
    def __init__(self, client):
        self.client = client
    
    async def create_user_with_preferences(self, username, email, preferences):
        # Create user
        user = await self.client.users.create(
            username=username,
            metadata={
                "email": email,
                "preferences": preferences,
                "created_at": datetime.now().isoformat()
            }
        )
        
        # Create initial session
        session = await self.client.sessions.create(
            user_id=user.id,
            metadata={
                "type": "initial_setup",
                "created_at": datetime.now().isoformat()
            }
        )
        
        # Set up user workspace
        workspace = await self.client.workspaces.create(
            name=f"{username}'s Workspace",
            metadata={
                "owner_id": user.id,
                "created_at": datetime.now().isoformat()
            }
        )
        
        # Update user with workspace
        updated_user = await self.client.users.update(
            user.id,
            metadata={
                **user.metadata,
                "workspace_id": workspace.id
            }
        )
        
        return {
            "user": updated_user,
            "session": session,
            "workspace": workspace
        }
    
    async def archive_user(self, user_id):
        # Get user data
        user = await self.client.users.get(user_id)
        
        # End all sessions
        sessions = await self.client.sessions.list(
            user_id=user_id,
            status="active"
        )
        for session in sessions:
            await self.client.sessions.end(session.id)
        
        # Archive workspace
        if "workspace_id" in user.metadata:
            await self.client.workspaces.update(
                user.metadata["workspace_id"],
                metadata={
                    "status": "archived",
                    "archived_at": datetime.now().isoformat()
                }
            )
        
        # Archive user
        archived_user = await self.client.users.update(
            user_id,
            metadata={
                **user.metadata,
                "status": "archived",
                "archived_at": datetime.now().isoformat()
            }
        )
        
        return archived_user
    
    async def get_user_activity(self, user_id):
        # Get user sessions
        sessions = await self.client.sessions.list(
            user_id=user_id,
            limit=100
        )
        
        # Get user interactions
        interactions = await self.client.interactions.list(
            user_id=user_id,
            limit=100
        )
        
        # Analyze activity
        activity_summary = {
            "total_sessions": len(sessions),
            "active_sessions": sum(1 for s in sessions if s.status == "active"),
            "total_interactions": len(interactions),
            "last_active": max(s.created_at for s in sessions),
            "interaction_types": Counter(i.type for i in interactions)
        }
        
        return activity_summary

# Use the manager
manager = UserManager(client)

# Create new user
result = await manager.create_user_with_preferences(
    username="jane_doe",
    email="jane@example.com",
    preferences={
        "language": "en",
        "timezone": "UTC",
        "theme": "light"
    }
)

print("Created user:", result["user"].id)
print("Initial session:", result["session"].id)
print("Workspace:", result["workspace"].id)

# Get user activity
activity = await manager.get_user_activity(result["user"].id)
print("User activity:", activity)

# Archive user
archived = await manager.archive_user(result["user"].id)
print("Archived user:", archived.id)

​
Next Steps

  1. Learn about user context
  2. Explore user sessions
  3. Understand session management