# Text search for broad matching
general_results = await memory.search("authentication")

# Tag search for precise filtering
tagged_results = await memory.search_by_tag(["auth", "security"])

# Time-based for recent context
recent_results = await memory.recall("last week")

# daily_summary.py
import schedule
import asyncio
from datetime import datetime, timedelta

async def daily_memory_summary():
    # Collect today's memories
    today = datetime.now().date()
    memories = await memory_service.recall(f"today")
    
    # Generate summary
    summary = f"Daily Summary for {today}:\n"
    summary += f"- Total memories: {len(memories)}\n"
    summary += f"- Key topics: {extract_topics(memories)}\n"
    summary += f"- Completed tasks: {count_completed(memories)}\n"
    
    # Store summary
    await memory_service.store(
        content=summary,
        tags=["daily-summary", str(today)]
    )

# Schedule for 6 PM daily
schedule.every().day.at("18:00").do(lambda: asyncio.run(daily_memory_summary()))

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/memory/store', methods=['POST'])
async def store_memory():
    data = request.json
    result = await memory_service.store(
        content=data['content'],
        tags=data.get('tags', [])
    )
    return jsonify({"id": result.id})

@app.route('/memory/search', methods=['GET'])
async def search_memories():
    query = request.args.get('q')
    results = await memory_service.search(query)
    return jsonify([r.to_dict() for r in results])

class DecisionLogger:
    def __init__(self, memory_service):
        self.memory = memory_service
    
    async def log_decision(self, decision_type, title, rationale, alternatives):
        content = f"""
        Decision: {title}
        Type: {decision_type}
        Date: {datetime.now().isoformat()}
        
        Rationale: {rationale}
        
        Alternatives Considered:
        {chr(10).join(f'- {alt}' for alt in alternatives)}
        """
        
        await self.memory.store(
            content=content,
            tags=['decision', decision_type, 'architecture']
        )

async def share_team_update(update_type, content, team_members):
    # Store in memory with team visibility
    memory = await memory_service.store(
        content=f"Team Update ({update_type}): {content}",
        tags=['team-update', update_type, 'shared']
    )
    
    # Notify team members (example with Slack)
    for member in team_members:
        await notify_slack(
            channel=member.slack_id,
            message=f"New {update_type} update stored: {memory.id}"
        )

# ❌ Inefficient: Multiple separate searches
results1 = await search("python")
results2 = await search("debugging")
results3 = await search("error")

# ✅ Efficient: Combined search
results = await search("python debugging error")

# For browsing
results = await search(query, limit=10)

# For existence check
results = await search(query, limit=1)

# For analysis
results = await search(query, limit=50)

# ❌ Individual operations
for memory in memories:
    await store_memory(memory)

# ✅ Batch operation
await store_memories_batch(memories)

# Custom JWT validation example
from jose import jwt, JWTError

async def validate_oauth_token(token: str):
    try:
        payload = jwt.decode(
            token,
            settings.oauth_secret_key,
            algorithms=["HS256"],
            audience=settings.jwt_audience,
            issuer=settings.jwt_issuer
        )
        return payload
    except JWTError:
        raise HTTPException(status_code=401, detail="Invalid token")

# ❌ Don't store
- Passwords or API keys
- Personal identification numbers
- Credit card information
- Private keys
- OAuth client secrets

# ✅ Store references instead
"AWS credentials stored in vault under key 'prod-api-key'"
"OAuth client configured with environment variables"

# Tag sensitive memories
await store_memory(
    content="Architecture decision for payment system",
    tags=["architecture", "payments", "confidential"]
)

# OAuth scope-based access
@require_scope("admin")
async def admin_endpoint():
    return sensitive_data

# Set expiration for temporary data
await store_memory(
    content="Temporary debug log",
    tags=["debug", "temporary"],
    metadata={"expires": "2025-08-01"}
)

# OAuth token cleanup
export MCP_OAUTH_CLEANUP_EXPIRED_TOKENS=true
export MCP_OAUTH_TOKEN_CLEANUP_INTERVAL="1h"

# Decision tracking
f"Decision: {title} | Rationale: {why} | Date: {when}"

# Error documentation  
f"Error: {message} | Solution: {fix} | Prevention: {how}"

# Learning capture
f"TIL: {concept} | Source: {where} | Application: {how}"