Skip to main content

Personality Manager API Reference

The Personality Manager is a core component of FlavumHive that handles AI personality states, behaviors, and interactions across different platforms.

Class Definition​

class PersonalityManager:
    """
    Manages AI personalities and their interactions.
    
    Attributes:
        personalities (Dict[str, Personality]): Active personality instances
        active_personality (str): Currently active personality name
        openai_client (OpenAIClient): OpenAI API client instance
    """
    
    def __init__(self):
        self.personalities = {}
        self.active_personality = None
        self.openai_client = None

Core Methods​

Initialize Personality​

async def initialize_personality(
    self,
    name: str,
    config: Dict[str, Any]
) -> bool:
    """
    Initialize a new personality instance.
    
    Args:
        name: Personality identifier
        config: Personality configuration
        
    Returns:
        bool: Success status
    """

Switch Active Personality​

async def switch_personality(
    self,
    name: str
) -> bool:
    """
    Switch to a different personality.
    
    Args:
        name: Target personality name
        
    Returns:
        bool: Success status
    """

Generate Response​

async def generate_response(
    self,
    context: Dict[str, Any],
    platform: str
) -> str:
    """
    Generate a platform-specific response.
    
    Args:
        context: Interaction context
        platform: Target platform
        
    Returns:
        str: Generated response
    """

State Management​

Save Personality State​

async def save_personality_state(
    self,
    name: str
) -> bool:
    """
    Save current personality state.
    
    Args:
        name: Personality name
        
    Returns:
        bool: Success status
    """

Load Personality State​

async def load_personality_state(
    self,
    name: str
) -> bool:
    """
    Load saved personality state.
    
    Args:
        name: Personality name
        
    Returns:
        bool: Success status
    """

OpenAI Integration​

Configure OpenAI​

def configure_openai(
    self,
    api_key: str,
    model: str = "gpt-4"
) -> None:
    """
    Configure OpenAI integration.
    
    Args:
        api_key: OpenAI API key
        model: Model identifier
    """

Generate Content​

async def generate_content(
    self,
    prompt: str,
    context: Dict[str, Any]
) -> str:
    """
    Generate content using OpenAI.
    
    Args:
        prompt: Input prompt
        context: Generation context
        
    Returns:
        str: Generated content
    """

Error Handling​

class PersonalityError(Exception):
    """Base class for personality-related errors."""
    pass

class StateError(PersonalityError):
    """State management errors."""
    pass

class GenerationError(PersonalityError):
    """Content generation errors."""
    pass

Usage Example​

# Initialize manager
manager = PersonalityManager()
await manager.configure_openai(api_key="your-key")

# Load personality
config = {
    "name": "crypto_expert",
    "traits": {...},
    "platforms": {...}
}
await manager.initialize_personality("crypto_expert", config)

# Generate response
response = await manager.generate_response(
    context={"query": "What's your view on DeFi?"},
    platform="twitter"
)

Best Practices​

  1. State Management

    • Regularly save personality states
    • Handle state conflicts
    • Implement recovery mechanisms

  2. Content Generation

    • Use appropriate temperature settings
    • Implement retry logic
    • Validate outputs

  3. Platform Integration

    • Respect platform limits
    • Handle rate limiting
    • Format content appropriately

See Also​