Upload 7 files

debug_credentials.js

@@ -0,0 +1,38 @@
+const { QdrantClient } = require("@qdrant/js-client-rest");
+require('dotenv').config({ path: './.env' });
+
+async function check(url, key) {
+    console.log(`\nTesting URL: ${url}`);
+    const client = new QdrantClient({
+        url: url,
+        apiKey: key,
+        checkCompatibility: false
+    });
+    try {
+        const result = await client.getCollections();
+        console.log("SUCCESS: Connected!");
+        return true;
+    } catch (e) {
+        console.log(`FAILED (${e.status || '?'}) : ${e.message}`);
+        return false;
+    }
+}
+
+async function debug() {
+    const originalUrl = process.env.QDRANT_URL;
+    const key = process.env.QDRANT_API_KEY;
+
+    // Test 1: As provided
+    await check(originalUrl, key);
+
+    // Test 2: Without Port
+    if (originalUrl.includes(':6333')) {
+        const noPortUrl = originalUrl.replace(':6333', '');
+        const success = await check(noPortUrl, key);
+        if (success) {
+            console.log("\nRECOMMENDATION: Remove ':6333' from your QDRANT_URL in .env");
+        }
+    }
+}
+
+debug();

index.js

@@ -0,0 +1,102 @@
+const express = require('express');
+const cors = require('cors');
+const path = require('path');
+require('dotenv').config({ path: path.resolve(__dirname, '.env') });
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+app.use(cors());
+app.use(express.json());
+
+const { app: workflow } = require('./workflow');
+
+const { storeResearch, chatResearch } = require('./rag/researchRag');
+const { storeInsights, chatInsights } = require('./rag/synthesisRag');
+const { storeSummary, chatExecutive } = require('./rag/executiveRag');
+
+app.get('/api/analyze', async (req, res) => {
+  const { query } = req.query;
+  
+  if (!query) {
+    return res.status(400).json({ error: 'Query is required' });
+  }
+
+  // Set SSE headers
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+
+  try {
+    console.log(`Starting workflow stream for: ${query}`);
+    
+    // Reset or clear previous collections if needed? 
+    // For now we just append. In a real app we might use session IDs.
+    
+    const stream = await workflow.stream({ query });
+
+    for await (const chunk of stream) {
+        // LangGraph returns chunks like { nodeName: { key: val } }
+        // We will send specific events for each update
+        
+        if (chunk.researchNode) {
+            const content = chunk.researchNode.research;
+            res.write(`data: ${JSON.stringify({ type: 'research', content })}\n\n`);
+            // Async store to RAG
+            storeResearch(content).catch(err => console.error("RAG Store Error:", err));
+        }
+        if (chunk.synthesisNode) {
+            const content = chunk.synthesisNode.insights;
+            res.write(`data: ${JSON.stringify({ type: 'insights', content })}\n\n`);
+            storeInsights(content).catch(err => console.error("RAG Store Error:", err));
+        }
+        if (chunk.executiveNode) {
+            const content = chunk.executiveNode.executiveSummary;
+            res.write(`data: ${JSON.stringify({ type: 'executiveSummary', content })}\n\n`);
+            storeSummary(content).catch(err => console.error("RAG Store Error:", err));
+        }
+    }
+    
+    res.write('data: [DONE]\n\n');
+    res.end();
+  } catch (error) {
+    console.error('Error in workflow stream:', error);
+    res.write(`data: ${JSON.stringify({ error: 'Internal server error' })}\n\n`);
+    res.end();
+  }
+});
+
+app.post('/api/chat', async (req, res) => {
+    const { agentRole, message, history } = req.body;
+    
+    if (!message || !agentRole) {
+        return res.status(400).json({ error: "Message and agentRole are required" });
+    }
+
+    try {
+        let response;
+        switch (agentRole) {
+            case 'research':
+                response = await chatResearch(message, history);
+                break;
+            case 'synthesis':
+                response = await chatInsights(message, history);
+                break;
+            case 'executive':
+                response = await chatExecutive(message, history);
+                break;
+            default:
+                return res.status(400).json({ error: "Invalid agent role" });
+        }
+        
+        res.json({ reply: response });
+    } catch (error) {
+        console.error("Chat API Error:", error);
+        res.status(500).json({ error: "Failed to process chat message" });
+    }
+});
+
+app.listen(PORT, () => {
+  console.log(`Server running on port ${PORT}`);
+  console.log(`OpenAI API Key present: ${process.env.OPENAI_API_KEY ? 'Yes' : 'No'}`);
+});

model.js

@@ -0,0 +1,12 @@
+const { ChatOpenAI } = require("@langchain/openai");
+const path = require('path');
+require('dotenv').config({ path: path.resolve(__dirname, '.env') });
+
+// Initialize the model
+// We can use GPT-3.5-turbo or GPT-4o depending on needs and keys
+const model = new ChatOpenAI({
+  modelName: "gpt-4o", // or gpt-3.5-turbo
+  temperature: 0.7,
+});
+
+module.exports = { model };

package.json

@@ -0,0 +1,26 @@
+{
+  "name": "server",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@langchain/community": "^1.1.5",
+    "@langchain/core": "^1.1.16",
+    "@langchain/langgraph": "^1.1.1",
+    "@langchain/openai": "^1.2.3",
+    "@langchain/qdrant": "^1.0.1",
+    "@langchain/textsplitters": "^1.0.1",
+    "@qdrant/js-client-rest": "^1.16.2",
+    "cors": "^2.8.5",
+    "duck-duck-scrape": "^2.2.7",
+    "express": "^5.2.1",
+    "express-sse": "^1.0.0",
+    "langchain": "^1.2.11"
+  }
+}

test_raw.js

@@ -0,0 +1,26 @@
+require('dotenv').config({ path: './.env' });
+
+async function testRaw() {
+    const url = process.env.QDRANT_URL.replace(/\/$/, ''); // remove trailing slash
+    const key = process.env.QDRANT_API_KEY;
+    const cleanUrl = url.replace(':6333', ''); // Try without port for Cloud
+
+    console.log(`Trying: ${cleanUrl}/collections`);
+    
+    try {
+        const response = await fetch(`${cleanUrl}/collections`, {
+            method: 'GET',
+            headers: {
+                'api-key': key
+            }
+        });
+
+        console.log(`Status: ${response.status}`);
+        const text = await response.text();
+        console.log(`Body: ${text}`);
+    } catch (e) {
+        console.error("Fetch failed:", e);
+    }
+}
+
+testRaw();

workflow.js

@@ -0,0 +1,52 @@
+const { StateGraph, END } = require("@langchain/langgraph");
+const { researchAgent } = require('./agents/researchAgent');
+const { synthesisAgent } = require('./agents/synthesisAgent');
+const { executiveAgent } = require('./agents/executiveAgent');
+
+// Define the state channels
+// We are using a simple object state where each agent appends/updates keys.
+const graphState = {
+  query: null,
+  research: null,
+  insights: null,
+  executiveSummary: null
+};
+
+// Define the graph
+const workflow = new StateGraph({
+  channels: {
+    query: {
+      value: (x, y) => y ? y : x,
+      default: () => ""
+    },
+    research: {
+        value: (x, y) => y ? y : x,
+        default: () => ""
+      },
+      insights: {
+        value: (x, y) => y ? y : x,
+        default: () => ""
+      },
+      executiveSummary: {
+        value: (x, y) => y ? y : x,
+        default: () => ""
+      }
+  }
+});
+
+// Add nodes
+workflow.addNode("researchNode", researchAgent);
+workflow.addNode("synthesisNode", synthesisAgent);
+workflow.addNode("executiveNode", executiveAgent);
+
+// Add API edges
+workflow.setEntryPoint("researchNode");
+workflow.addEdge("researchNode", "synthesisNode");
+workflow.addEdge("synthesisNode", "executiveNode");
+workflow.addEdge("executiveNode", END);
+
+// Compile the graph
+const app = workflow.compile();
+
+// Export the app directly to allow streaming
+module.exports = { app };