Analyze this research content using your persistent memory of previous analyses:

CONTENT: {{parsed_content}}
CONTEXT: Remember previous research on {{topic}} and related findings
MEMORY: Reference any related papers or themes we've analyzed before

Provide:
1. SUMMARY: 3-sentence key takeaway
2. RELEVANCE: How this connects to previous research in our memory
3. IMPLICATIONS: What this means for {{research_domain}}
4. QUESTIONS: 3 follow-up research directions
5. MEMORY_UPDATE: Key facts to remember about this research

Use your memory to provide continuity and avoid repetitive analysis.

// Advanced research automation with persistent AI memory
class MemoryEnabledResearch {
    constructor(config) {
        this.zepClient = new ZepClient(config.zepApiKey);
        this.sessionId = config.sessionId || 'research_memory';
        this.researchDomain = config.researchDomain;
    }
    
    async processResearch(contentData) {
        // Retrieve relevant memory context
        const memoryContext = await this.getRelevantMemory(contentData.topic);
        
        // Analyze with memory context
        const analysis = await this.analyzeWithMemory(contentData, memoryContext);
        
        // Update persistent memory
        await this.updateResearchMemory(contentData, analysis);
        
        // Generate insights
        const insights = await this.generateInsights(analysis, memoryContext);
        
        return {
            analysis,
            insights,
            memoryConnections: memoryContext.connections,
            followUpActions: insights.recommendations
        };
    }
    
    async getRelevantMemory(topic) {
        const searchQuery = `research related to ${topic} in ${this.researchDomain}`;
        
        const memoryResults = await this.zepClient.searchMemory({
            sessionId: this.sessionId,
            query: searchQuery,
            limit: 10,
            mmr_lambda: 0.7 // Balance relevance vs diversity
        });
        
        return {
            relatedResearch: memoryResults.results,
            connections: this.findTopicalConnections(memoryResults),
            historicalContext: this.extractTimelineContext(memoryResults)
        };
    }
    
    async analyzeWithMemory(content, memoryContext) {
        const prompt = `
            Analyze this research with context from our research memory:
            
            NEW RESEARCH:
            Title: ${content.title}
            Authors: ${content.authors}
            Abstract: ${content.abstract}
            Key Findings: ${content.findings}
            
            MEMORY CONTEXT:
            Previous Research: ${JSON.stringify(memoryContext.relatedResearch)}
            Historical Timeline: ${memoryContext.historicalContext}
            
            ANALYSIS FRAMEWORK:
            1. Novelty Assessment: What's genuinely new vs incremental?
            2. Memory Connections: How does this build on/contradict previous work?
            3. Research Trajectory: Where does this fit in the field's evolution?
            4. Gap Analysis: What questions remain unanswered?
            5. Synthesis Opportunities: What new research directions emerge?
            
            Provide contextual analysis that leverages our accumulated knowledge.
        `;
        
        return await this.callAI(prompt);
    }
    
    async updateResearchMemory(content, analysis) {
        // Create rich memory entry
        const memoryEntry = {
            type: 'research_analysis',
            content: {
                title: content.title,
                summary: analysis.summary,
                keyInsights: analysis.insights,
                connections: analysis.connections,
                significance: analysis.significanceScore
            },
            metadata: {
                domain: this.researchDomain,
                analysisDate: new Date().toISOString(),
                sourceType: content.sourceType
            }
        };
        
        // Store in Zep with graph relationships
        await this.zepClient.addMemory({
            sessionId: this.sessionId,
            message: JSON.stringify(memoryEntry),
            metadata: memoryEntry.metadata
        });
        
        // Update knowledge graph connections
        await this.updateKnowledgeGraph(content, analysis);
    }
    
    async generateInsights(analysis, memoryContext) {
        const insightPrompt = `
            Generate actionable research insights based on analysis and memory:
            
            CURRENT ANALYSIS: ${JSON.stringify(analysis)}
            MEMORY CONNECTIONS: ${JSON.stringify(memoryContext)}
            
            Generate:
            1. Research Recommendations: Next papers to investigate
            2. Synthesis Opportunities: Where to combine findings
            3. Collaboration Signals: Researchers/institutions to engage
            4. Timeline Priorities: When to act on these insights
            5. Resource Requirements: What's needed for follow-up
            
            Focus on actionable next steps that leverage our accumulated knowledge.
        `;
        
        return await this.callAI(insightPrompt);
    }
}

// Webhook for content processing
app.post('/process-research', async (req, res) => {
    try {
        const contentData = req.body;
        const researcher = new MemoryEnabledResearch({
            zepApiKey: process.env.ZEP_API_KEY,
            sessionId: `research_${req.user.id}`,
            researchDomain: req.user.researchDomain
        });
        
        const result = await researcher.processResearch(contentData);
        
        // Trigger dashboard updates
        await updateResearchDashboard(result);
        
        // Send smart notifications
        await sendContextualAlerts(result, req.user.preferences);
        
        res.json({ 
            success: true, 
            analysis: result.analysis,
            insights: result.insights,
            memoryConnections: result.memoryConnections.length
        });
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});