Learnings from an OnlyFans-Based AI Project

📥 1. Flask API Endpoint
    ├── `/generate_opener`
    ├── `/generate_reply`
    └── `/update_user_profile`
     │
     ▼
🔐 2. Authentication Layer
    └── Validates `X-Secret-Key` from request header
     │
     ▼
🧠 3. Context Assembly
    ├── Retrieve past conversation via ChromaDB (RAG)
    ├── Retrieve user profile (preferences, interests)
    ├── Thread ID for ongoing session
     │
     ▼
🗃️ 4. Vector Memory Layer (ChromaDB)
    ├── Uses `SentenceTransformerEmbedding` for:
    │     ├── Contextual retrieval
    │     └── CTA detection
    └── Stores:
          ├── Messages (user + AI)
          ├── Metadata (timestamps, thread_id)
          └── User profiles
     │
     ▼
🛠️ 5. Prompt Engineering
    ├── Persona + mood + slang settings
    ├── CTA strategy based on engagement stage
    ├── Injects retrieved history and personalization
    └── Output formatted as JSON with `messages`, `media`, `cta_triggered`
     │
     ▼
🔮 6. LLM Inference (Based on Config)
    ├── [OpenAI GPT-4o] → API call to generate response
    └── [Ollama Dolphin3] → Local API call for less restrictions on intimate chats
     │
     ▼
🧾 7. Response Parsing & CTA Check
    ├── Extracts JSON content from LLM response
    ├── Confirms CTA via semantic similarity (NumPy cosine)
    └── Flags if CTA is embedded
     │
     ▼
🗨️ 8. Final AI Response
    └── Returns:
          ├── Chat bubbles (Gen-Z style)
          ├── Suggested media (nullable)
          └── `cta_triggered: true/false`
     │
     ▼
🧠 9. Logging + Storage
    ├── Adds assistant/user messages to ChromaDB
    └── Periodic summarization + memory pruning

# Real implementation from app.py
import chromadb
from chromadb.utils import embedding_functions

def initialize_vector_store():
    global chroma_client, conversation_collection, sentence_transformer_ef, cta_embeddings

    sentence_transformer_ef = embedding_functions.SentenceTransformerEmbeddingFunction(
        model_name="all-mpnet-base-v2"  # Production model choice
    )

    chroma_client = chromadb.PersistentClient(path=VECTOR_STORE_PATH)
    conversation_collection = chroma_client.get_or_create_collection(
        name="conversations",
        embedding_function=sentence_transformer_ef,
        metadata={"hnsw:space": "cosine"}  # Using cosine similarity
    )

    # Initialize CTA embeddings for semantic detection
    cta_examples = [
        "check out my OnlyFans for more 😉",
        "subscribe to my exclusive content when you have time",
        "my link in bio has all the spicy content ❤️",
        "there's more on my OF if you're interested",
        "have you seen my exclusive content yet?",
        "you should totally check out the link in my bio",
        "I have something special on my page if you wanna see"
    ]
    cta_embeddings = [sentence_transformer_ef([example])[0] for example in cta_examples]

def get_relevant_history(thread_id: str, query_text: str, k: int) -> list:
    # Retrieve more results initially for better re-ranking
    initial_results = min(k * 2, 20)
    results = conversation_collection.query(
        query_texts=[query_text],
        n_results=initial_results,
        where={"thread_id": thread_id},
        include=["metadatas", "documents"]
    )

    retrieved_messages = []
    if results and results['metadatas'] and results['metadatas'][0]:
        for i in range(len(results['metadatas'][0])):
            meta = results['metadatas'][0][i]
            original_content = meta.get("original_content", results['documents'][0][i])
            retrieved_messages.append({
                "role": meta["role"],
                "content": original_content,
                "timestamp": meta["timestamp"],
                "relevance_score": 1.0 / (i + 1)  # Simple relevance scoring
            })

    # Sort by timestamp to maintain conversation flow
    retrieved_messages.sort(key=lambda x: x["timestamp"])
    return retrieved_messages[:k]

# Real API endpoints from app.py
@app.route('/generate_opener', methods=['POST'])
def generate_opener():
    """Generate conversation opening messages"""
    # Validates authentication, processes model settings,
    # generates contextual conversation starters
    pass

@app.route('/generate_reply', methods=['POST'])
def generate_reply():
    """Generate contextual replies based on conversation history"""
    # Retrieves conversation history via RAG
    # Applies user profiling and sentiment analysis
    # Returns JSON with messages, media suggestions, CTA flags
    pass

@app.route('/update_user_profile', methods=['POST'])
def update_user_profile():
    """Update user profile information for personalization"""
    # Stores user preferences, interests, communication style
    # Used for future conversation personalization
    pass

@app.route('/conversation_cleanup', methods=['POST'])
def cleanup_conversation():
    """Clean old messages to prevent memory bloat"""
    # Implements smart memory management
    # Keeps recent context while clearing old data
    pass

@app.route('/health', methods=['GET'])
def health_check():
    """System health monitoring endpoint"""
    return jsonify({
        "status": "healthy",
        "vector_store": "connected" if conversation_collection else "disconnected",
        "llm_provider": USE_API_PROVIDER
    })

# Real implementation from app.py
def detect_cta_semantic(message_content: str) -> bool:
    """
    Detect if a message contains a CTA using semantic similarity
    """
    if not cta_embeddings or not sentence_transformer_ef:
        # Fallback to keyword detection
        cta_keywords = ["onlyfans", "of", "link in bio", "exclusive content", "subscribe", "my page"]
        message_lower = message_content.lower()
        return any(keyword in message_lower for keyword in cta_keywords)

    try:
        # Get embedding for the message
        message_embedding = sentence_transformer_ef([message_content])[0]

        # Calculate cosine similarity with each CTA example
        max_similarity = 0.0
        for cta_embedding in cta_embeddings:
            similarity = np.dot(message_embedding, cta_embedding) / (
                np.linalg.norm(message_embedding) * np.linalg.norm(cta_embedding)
            )
            max_similarity = max(max_similarity, similarity)

        is_cta = max_similarity > CTA_SIMILARITY_THRESHOLD
        app.logger.info(f"CTA detection: max_similarity={max_similarity:.3f}, threshold={CTA_SIMILARITY_THRESHOLD}, is_cta={is_cta}")
        return is_cta

    except Exception as e:
        app.logger.error(f"Error in semantic CTA detection: {e}")
        return False

# Real implementation from app.py
def store_user_profile_info(thread_id: str, user_info: dict):
    """Store user profile information for personalized responses"""
    if not conversation_collection:
        return

    try:
        profile_id = f"{thread_id}_profile_{uuid.uuid4().hex[:8]}"
        timestamp = datetime.utcnow().isoformat()

        conversation_collection.add(
            documents=[json.dumps(user_info)],
            metadatas=[{
                "thread_id": thread_id,
                "type": "user_profile",
                "timestamp": timestamp,
                "profile_data": user_info
            }],
            ids=[profile_id]
        )
        app.logger.info(f"Stored user profile for thread {thread_id}")
    except Exception as e:
        app.logger.error(f"Error storing user profile: {e}")

def clean_old_messages(thread_id: str, keep_recent: int = 100):
    """Clean old messages to prevent memory bloat while keeping recent context"""
    if not conversation_collection:
        return

    try:
        # Get all messages for this thread, sorted by timestamp
        results = conversation_collection.query(
            query_texts=[""],
            where={"thread_id": thread_id},
            n_results=1000,  # Get many to sort and filter
            include=["metadatas"]
        )

        if not results or not results['metadatas'] or not results['metadatas'][0]:
            return

        # Sort by timestamp and keep only recent ones
        messages_with_meta = [(meta, idx) for idx, meta in enumerate(results['metadatas'][0])]
        messages_with_meta.sort(key=lambda x: x[0]['timestamp'], reverse=True)

        # Delete older messages beyond keep_recent threshold
        if len(messages_with_meta) > keep_recent:
            old_messages = messages_with_meta[keep_recent:]
            for meta, _ in old_messages:
                conversation_collection.delete(where={"timestamp": meta['timestamp']})

        app.logger.info(f"Cleaned old messages for thread {thread_id}, kept {keep_recent} recent")
    except Exception as e:
        app.logger.error(f"Error cleaning old messages: {e}")

from cryptography.fernet import Fernet
import hashlib
import secrets

class SecureDataHandler:
    def __init__(self):
        self.encryption_key = self._generate_encryption_key()
        self.fernet = Fernet(self.encryption_key)

    def store_user_data(self, user_id, conversation_data):
        """
        Secure storage with encryption:
        - PII data encrypted at rest
        - Conversation history anonymized
        - User preferences hashed
        """
        anonymized_id = hashlib.sha256(f"{user_id}{secrets.token_hex(16)}".encode()).hexdigest()
        encrypted_data = self.fernet.encrypt(conversation_data.encode())

        return {
            'anonymous_id': anonymized_id,
            'encrypted_content': encrypted_data,
            'storage_timestamp': datetime.utcnow()
        }

from flask_limiter import Limiter
from flask_limiter.util import get_remote_address

limiter = Limiter(
    app,
    key_func=get_remote_address,
    default_limits=["200 per day", "50 per hour", "1 per second"]
)

@app.route('/generate_reply', methods=['POST'])
@limiter.limit("10 per minute")
def generate_reply():
    """Rate-limited endpoint with resource monitoring"""
    pass

from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification

class EmotionalIntelligence:
    def __init__(self):
        self.sentiment_analyzer = pipeline(
            "sentiment-analysis",
            model="cardiffnlp/twitter-roberta-base-sentiment-latest",
            device=0  # GPU acceleration
        )
        self.emotion_detector = pipeline(
            "text-classification",
            model="j-hartmann/emotion-english-distilroberta-base"
        )

    def analyze_user_state(self, message_history):
        """
        Real-time emotional state analysis:
        - Sentiment trajectory over conversation
        - Emotion intensity mapping
        - Engagement level prediction
        """
        emotions = []
        sentiments = []

        for msg in message_history[-10:]:  # Last 10 messages
            emotion = self.emotion_detector(msg['content'])[0]
            sentiment = self.sentiment_analyzer(msg['content'])[0]

            emotions.append(emotion)
            sentiments.append(sentiment)

        return {
            'current_mood': emotions[-1]['label'],
            'mood_intensity': emotions[-1]['score'],
            'sentiment_trend': self._calculate_trend(sentiments),
            'engagement_prediction': self._predict_engagement(emotions, sentiments)
        }

class ConversationExperiment:
    def __init__(self):
        self.variants = {
            'control': {'cta_approach': 'baseline', 'slang_usage': 'moderate'},
            'variant_a': {'cta_approach': 'subtle', 'slang_usage': 'high'},
            'variant_b': {'cta_approach': 'contextual', 'slang_usage': 'low'}
        }

    def assign_variant(self, user_id):
        """Consistent user assignment to experimental groups"""
        hash_value = int(hashlib.md5(user_id.encode()).hexdigest(), 16)
        return ['control', 'variant_a', 'variant_b'][hash_value % 3]

    def track_outcomes(self, user_id, variant, interaction_data):
        """Track conversation engagement and success patterns"""
        metrics = {
            'user_id': user_id,
            'variant': variant,
            'engagement_signals': interaction_data['user_responses'],
            'conversation_flow': interaction_data['message_progression'],
            'contextual_relevance': interaction_data['topic_alignment']
        }
        self._log_experiment_data(metrics)

# Planned implementations
upcoming_features = {
    'sentiment_based_media': 'Smart image selection based on emotional context',
    'multimodal_embeddings': 'CLIP-based image-text understanding',
    'voice_synthesis': 'ElevenLabs integration for voice responses',
    'predictive_analytics': 'User behavior prediction models',
    'real_time_personalization': 'Dynamic persona adaptation',
    'cross_platform_sync': 'Unified user experience across platforms'
}