Message Compression & Summarization

GET /v1/messages/sessions/{sessionId}/compress

"User is debugging JWT token refresh timing issues in their React authentication 
flow. The tokens are expiring correctly but the refresh mechanism isn't triggering 
at the right time. Currently checking the expiry calculation logic in useAuth.ts."

"Over the past 100 messages, user has been building a complete JWT authentication 
system for their React task app. Started with basic login/signup forms, then 
implemented token generation on backend, switched from localStorage to httpOnly 
cookies for security, and is now working on token refresh logic. Key challenge 
has been getting the timing right for automatic token refresh."

"Full project: User is building a task management SaaS application with React 
frontend and Node.js backend. Started by asking about React best practices, then 
architected the application structure, implemented database schema with PostgreSQL, 
built REST API with Express, created authentication system with JWT tokens, and is 
now working on the authorization layer with role-based access control. Tech stack: 
React, TypeScript, Node.js, Express, PostgreSQL, JWT. Current phase: Security 
implementation."

{
  "session_intent": "Build secure JWT authentication for task management app with httpOnly cookies and automatic token refresh"
}

{
  "key_decisions": [
    "Use httpOnly cookies instead of localStorage for JWT storage (XSS protection)",
    "Implement 5-minute refresh buffer before token expiry (prevent auth interruptions)",
    "Choose React Context over Redux for auth state (simpler for this use case)",
    "Set token expiry to 1 hour with 7-day refresh token (balance security and UX)"
  ]
}

{
  "current_state": "Working: JWT generation and validation, httpOnly cookie storage, login/logout flow. Not working: Token refresh timing is off by ~2 minutes, protected routes occasionally redirect to login incorrectly"
}

{
  "next_steps": [
    "Debug token expiry calculation in useAuth.ts (check timezone handling)",
    "Add loading states to prevent double-refresh attempts",
    "Implement ProtectedRoute component with proper redirect logic",
    "Write integration tests for token refresh flow",
    "Add error handling for network failures during refresh"
  ]
}

{
  "technical_details": [
    "Token expiry: 3600 seconds (1 hour)",
    "Refresh token expiry: 604800 seconds (7 days)",
    "Login endpoint: POST /api/auth/login",
    "Refresh endpoint: POST /api/auth/refresh",
    "Cookie name: 'auth_token'",
    "Cookie settings: httpOnly=true, secure=true, sameSite=strict",
    "Error code for expired tokens: ERR_TOKEN_EXPIRED",
    "Auth hook: useAuth() from src/hooks/useAuth.ts"
  ]
}

{
  "files_accessed": {
    "read": [
      "src/components/Login.tsx",
      "src/api/auth.ts",
      "src/utils/tokenValidation.ts"
    ],
    "modified": [
      {
        "path": "src/components/Login.tsx",
        "description": "Added form validation with Yup schema and error display"
      },
      {
        "path": "src/api/auth.ts",
        "description": "Updated token handling to use httpOnly cookies instead of localStorage"
      },
      {
        "path": "src/hooks/useAuth.ts",
        "description": "Fixed token refresh timing calculation"
      }
    ],
    "created": [
      "src/hooks/useAuth.ts",
      "src/utils/tokenStorage.ts",
      "src/components/ProtectedRoute.tsx"
    ],
    "deleted": [
      "src/utils/localStorageAuth.ts"
    ]
  }
}

{
  "project_context": {
    "project_name": "Task Management SaaS",
    "project_id": "proj_task_management",
    "project_path": "/Users/dev/projects/task-app",
    "tech_stack": ["React", "TypeScript", "Node.js", "Express", "PostgreSQL", "JWT"],
    "current_task": "Implementing JWT authentication with httpOnly cookies and token refresh",
    "git_repo": "https://github.com/user/task-app"
  }
}

{
  "session_id": "session_abc123",
  "summaries": {
    "short_term": "User is debugging token refresh timing...",
    "medium_term": "Over the past 100 messages, user has built...",
    "long_term": "Full project: Task management SaaS with React...",
    "topics": ["React", "JWT", "Authentication", "TypeScript", "Security"],
    "last_updated": "2026-02-11T14:30:00Z"
  },
  "enhanced_fields": {
    "session_intent": "Build secure JWT authentication...",
    "key_decisions": [
      "Use httpOnly cookies for XSS protection",
      "Implement 5-minute refresh buffer"
    ],
    "current_state": "Working: JWT generation. Not working: Refresh timing",
    "next_steps": [
      "Debug expiry calculation",
      "Add loading states",
      "Write integration tests"
    ],
    "technical_details": [
      "Token expiry: 3600 seconds",
      "Refresh endpoint: POST /api/auth/refresh"
    ],
    "files_accessed": {
      "read": ["src/api/auth.ts"],
      "modified": [
        {"path": "src/hooks/useAuth.ts", "description": "Fixed timing"}
      ],
      "created": ["src/components/ProtectedRoute.tsx"],
      "deleted": []
    },
    "project_context": {
      "project_name": "Task Management SaaS",
      "tech_stack": ["React", "TypeScript", "Node.js"],
      "current_task": "JWT authentication implementation"
    }
  },
  "from_cache": true,
  "message_count": 47
}

from papr_memory import Papr
import os

client = Papr(x_api_key=os.environ.get("PAPR_MEMORY_API_KEY"))

# Get compressed context
compressed = client.messages.compress_session(
    session_id="session_abc123"
)

# Check if from cache
if compressed.from_cache:
    print("✅ Near-instant response from cache")
else:
    print("🆕 Just generated")

# Access three-tier summaries
print(f"Recent: {compressed.summaries.short_term}")
print(f"Session: {compressed.summaries.medium_term}")
print(f"Full: {compressed.summaries.long_term}")

# Access enhanced fields
print(f"Goal: {compressed.enhanced_fields.session_intent}")
print(f"Status: {compressed.enhanced_fields.current_state}")
print(f"Next: {compressed.enhanced_fields.next_steps[0]}")

# Use in LLM prompt
system_prompt = f"""
You are helping with: {compressed.enhanced_fields.project_context.project_name}
Tech stack: {', '.join(compressed.enhanced_fields.project_context.tech_stack)}

Recent work:
{compressed.summaries.short_term}

Key decisions made:
{chr(10).join(f'- {d}' for d in compressed.enhanced_fields.key_decisions)}

Current status: {compressed.enhanced_fields.current_state}

Next steps:
{chr(10).join(f'{i+1}. {s}' for i, s in enumerate(compressed.enhanced_fields.next_steps))}
"""

# Feed to your LLM
response = your_llm.chat(
    system=system_prompt,
    user="How do I fix the token refresh timing issue?"
)

import Papr from '@papr/memory';

const client = new Papr({
  xAPIKey: process.env.PAPR_MEMORY_API_KEY
});

// Get compressed context
const compressed = await client.messages.compressSession({
  session_id: "session_abc123"
});

// Check if from cache
if (compressed.from_cache) {
    console.log('✅ Near-instant response from cache');
} else {
  console.log('🆕 Just generated');
}

// Access three-tier summaries
console.log(`Recent: ${compressed.summaries.short_term}`);
console.log(`Session: ${compressed.summaries.medium_term}`);
console.log(`Full: ${compressed.summaries.long_term}`);

// Access enhanced fields
console.log(`Goal: ${compressed.enhanced_fields.session_intent}`);
console.log(`Status: ${compressed.enhanced_fields.current_state}`);
console.log(`Next: ${compressed.enhanced_fields.next_steps[0]}`);

// Use in LLM prompt
const systemPrompt = `
You are helping with: ${compressed.enhanced_fields.project_context.project_name}
Tech stack: ${compressed.enhanced_fields.project_context.tech_stack.join(', ')}

Recent work:
${compressed.summaries.short_term}

Key decisions made:
${compressed.enhanced_fields.key_decisions.map(d => `- ${d}`).join('\n')}

Current status: ${compressed.enhanced_fields.current_state}

Next steps:
${compressed.enhanced_fields.next_steps.map((s, i) => `${i+1}. ${s}`).join('\n')}
`;

// Feed to your LLM
const response = await yourLLM.chat({
  system: systemPrompt,
  user: "How do I fix the token refresh timing issue?"
});

# Get compressed summary
curl -X GET "https://memory.papr.ai/v1/messages/sessions/session_abc123/compress" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "X-Client-Type: curl"

# Response (if summary exists)
{
  "session_id": "session_abc123",
  "summaries": { ... },
  "enhanced_fields": { ... },
  "from_cache": true,
  "message_count": 47
}

# Response (if no summary yet)
{
  "detail": "Session not found or no summary exists"
}
# (Wait a few seconds and try again - background processing triggered)

Message 1: User: "I'm building a React app..." (150 tokens)
Message 2: Assistant: "Great! Here's how..." (300 tokens)
Message 3: User: "How do I add JWT auth?" (80 tokens)
...
Message 50: Assistant: "To fix that, try..." (250 tokens)

TOTAL: ~50,000 tokens

{
  "summaries": {
    "short_term": "User debugging token refresh..." (200 tokens),
    "medium_term": "Built complete JWT auth system..." (500 tokens),
    "long_term": "Task management SaaS project..." (800 tokens)
  },
  "enhanced_fields": {
    "session_intent": "..." (50 tokens),
    "key_decisions": [...] (200 tokens),
    "current_state": "..." (100 tokens),
    "next_steps": [...] (150 tokens)
  }
}

TOTAL: ~2,000 tokens

# Use full history
history = client.messages.get_history(session_id=session_id, limit=20)
context = "\n".join([f"{msg.role}: {msg.content}" for msg in history.messages])

# Use short + medium summaries
compressed = client.messages.compress_session(session_id=session_id)
context = f"{compressed.summaries.medium_term}\n\nRecent:\n{compressed.summaries.short_term}"

# Use all three summaries + enhanced fields
compressed = client.messages.compress_session(session_id=session_id)
context = f"""
Project: {compressed.enhanced_fields.project_context.project_name}
Goal: {compressed.enhanced_fields.session_intent}

Full context: {compressed.summaries.long_term}

Recent work: {compressed.summaries.short_term}

Current status: {compressed.enhanced_fields.current_state}
Next steps: {', '.join(compressed.enhanced_fields.next_steps[:3])}
"""

Message 1-14: Stored in Parse PostMessage
Message 15: Triggers batch analysis
  ↓
Background processing (3 seconds):
  - Groq LLM analyzes all messages
  - Generates summaries and enhanced fields
  - Saves to Parse ChatSession
  - Creates Neo4j MessageSession node
  ↓
Cached for instant retrieval

New messages stored normally
  ↓
Message 30: Triggers re-analysis
  - Updates existing summaries
  - Appends to medium_term context
  - Updates long_term overview
  - Refreshes enhanced fields
  ↓
Cache updated

# Quick context for immediate continuation
short = compressed.summaries.short_term

# Understanding recent work flow
medium = compressed.summaries.medium_term

# High-level project overview
long = compressed.summaries.long_term

# Comprehensive context (combine all)
full_context = f"{long}\n\nRecent:\n{short}"

# Get compressed session context
compressed = client.messages.compress_session(session_id=session_id)

# Search for specific relevant memories
memories = client.memory.search(
    query="JWT token refresh implementation details",
    external_user_id=user_id,
    max_memories=5
)

# Combine for LLM
context = f"""
Session context: {compressed.summaries.medium_term}

Relevant memories:
{chr(10).join([m.content for m in memories.data.memories])}

Current task: {compressed.enhanced_fields.current_state}
"""

try:
    compressed = client.messages.compress_session(session_id=session_id)
    
    if compressed.from_cache:
        # Use cached summary
        context = compressed.summaries.short_term
    else:
        # Just generated, good to use
        context = compressed.summaries.short_term
        
except Exception as e:
    if "not found" in str(e).lower():
        # Summary doesn't exist yet (< 15 messages or still processing)
        # Fall back to recent history
        history = client.messages.get_history(session_id=session_id, limit=10)
        context = "\n".join([f"{msg.role}: {msg.content}" for msg in history.messages])
    else:
        raise

compressed = client.messages.compress_session(session_id=session_id)

if compressed.from_cache:
    print(f"✅ Near-instant retrieval from cache")
    print(f"📊 Based on {compressed.message_count} messages")
else:
    print(f"🆕 Just generated fresh summary")
    print(f"⏱️ Took ~3 seconds to process")

# Don't parse summaries manually - use structured fields
compressed = client.messages.compress_session(session_id=session_id)

# ❌ DON'T parse from summary text
# intent = extract_intent_from_text(compressed.summaries.long_term)

# ✅ DO use structured fields
intent = compressed.enhanced_fields.session_intent
decisions = compressed.enhanced_fields.key_decisions
next_steps = compressed.enhanced_fields.next_steps

# ✅ GOOD: Fetch once per task
compressed = client.messages.compress_session(session_id=session_id)
# ... use for multiple LLM calls ...

# ❌ BAD: Fetching on every message
for message in new_messages:
    compressed = client.messages.compress_session(session_id=session_id)  # Wasteful!
    # ... use once ...

compressed = client.messages.compress_session(session_id=session_id)

# Show what files were touched
files = compressed.enhanced_fields.files_accessed

print(f"📖 Read: {len(files.read)} files")
print(f"✏️ Modified: {len(files.modified)} files")
print(f"🆕 Created: {len(files.created)} files")
print(f"🗑️ Deleted: {len(files.deleted)} files")

# Use for context
if files.modified:
    recent_changes = [f"{m['path']}: {m['description']}" for m in files.modified]
    context = f"Recently changed:\n" + "\n".join(recent_changes)

try:
    compressed = client.messages.compress_session(session_id="invalid_session")
except Exception as e:
    if "not found" in str(e).lower():
        print("Session doesn't exist - check session ID")
    else:
        raise

try:
    compressed = client.messages.compress_session(session_id=session_id)
except Exception as e:
    if "no summary exists" in str(e).lower():
        print("Summary not generated yet - wait for 15 messages or try again in a few seconds")
        # Fall back to recent history
        history = client.messages.get_history(session_id=session_id, limit=10)
    else:
        raise

try:
    compressed = client.messages.compress_session(session_id=session_id)
except Exception as e:
    if "authentication" in str(e).lower() or "401" in str(e):
        print("API key invalid or missing")
    else:
        raise

{
  session_id: string;
  summaries: {
    short_term: string;
    medium_term: string;
    long_term: string;
    topics: string[];
    last_updated: string;
  };
  enhanced_fields: {
    session_intent?: string;
    key_decisions: string[];
    current_state?: string;
    next_steps: string[];
    technical_details: string[];
    files_accessed?: {
      read: string[];
      modified: Array<{path: string, description: string}>;
      created: string[];
      deleted: string[];
    };
    project_context?: {
      project_name?: string;
      project_id?: string;
      project_path?: string;
      tech_stack: string[];
      current_task?: string;
      git_repo?: string;
    };
  };
  from_cache: boolean;
  message_count: number;
}