Spaces:
Running
Running
import { Hono } from 'hono'; | |
import { streamSSE } from 'hono/streaming'; | |
import { v4 as uuidv4 } from 'uuid'; | |
import { z } from 'zod'; | |
import { config } from '../config'; | |
import { cache } from '../services/cache'; | |
import { vespaRequest } from '../services/vespa-https'; | |
const api = new Hono(); | |
// Search request schema | |
const searchQuerySchema = z.object({ | |
query: z.string().min(1).max(500), | |
ranking: z.enum(['hybrid', 'colpali', 'bm25']).optional().default('hybrid'), | |
}); | |
// Main search endpoint | |
api.get('/colpali-search', async (c) => { | |
try { | |
const query = c.req.query('query'); | |
const ranking = c.req.query('ranking') || 'hybrid'; | |
const validation = searchQuerySchema.safeParse({ query, ranking }); | |
if (!validation.success) { | |
return c.json({ error: 'Invalid request', details: validation.error.issues }, 400); | |
} | |
const validatedData = validation.data; | |
// Check cache | |
const cacheKey = `search:${validatedData.query}:${validatedData.ranking}`; | |
const cachedResult = cache.get(cacheKey); | |
if (cachedResult) { | |
c.header('X-Cache', 'HIT'); | |
return c.json(cachedResult); | |
} | |
// Build YQL query based on ranking | |
let yql = ''; | |
let rankProfile = 'default'; | |
switch (validatedData.ranking) { | |
case 'colpali': | |
yql = `select * from linqto where userQuery() limit 20`; | |
rankProfile = 'colpali'; | |
break; | |
case 'bm25': | |
yql = `select * from linqto where userQuery() limit 20`; | |
rankProfile = 'bm25'; | |
break; | |
case 'hybrid': | |
default: | |
yql = `select * from linqto where userQuery() limit 20`; | |
rankProfile = 'default'; | |
break; | |
} | |
// Query Vespa directly | |
const searchUrl = `${config.vespaAppUrl}/search/`; | |
const searchParams = new URLSearchParams({ | |
yql, | |
query: validatedData.query, | |
ranking: rankProfile, | |
hits: '20' | |
}); | |
const response = await vespaRequest(`${searchUrl}?${searchParams}`); | |
if (!response.ok) { | |
const errorText = await response.text(); | |
console.error('Vespa error:', errorText); | |
throw new Error(`Vespa returned ${response.status}: ${errorText}`); | |
} | |
const data = await response.json(); | |
// Generate query_id for sim_map compatibility | |
const queryId = uuidv4(); | |
// Transform to match expected format | |
if (data.root && data.root.children) { | |
data.root.children.forEach((hit: any, idx: number) => { | |
if (!hit.fields) hit.fields = {}; | |
// Add sim_map identifier for compatibility | |
hit.fields.sim_map = `${queryId}_${idx}`; | |
}); | |
} | |
// Cache the result | |
cache.set(cacheKey, data); | |
c.header('X-Cache', 'MISS'); | |
return c.json(data); | |
} catch (error) { | |
console.error('Search error:', error); | |
return c.json({ | |
error: 'Search failed', | |
message: error instanceof Error ? error.message : 'Unknown error' | |
}, 500); | |
} | |
}); | |
// Full image endpoint | |
api.get('/full-image', async (c) => { | |
try { | |
const docId = c.req.query('docId'); | |
if (!docId) { | |
return c.json({ error: 'docId is required' }, 400); | |
} | |
// Check cache | |
const cacheKey = `fullimage:${docId}`; | |
const cachedImage = cache.get<{ base64_image: string }>(cacheKey); | |
if (cachedImage) { | |
c.header('X-Cache', 'HIT'); | |
return c.json(cachedImage); | |
} | |
// Query Vespa for the document | |
const searchUrl = `${config.vespaAppUrl}/search/`; | |
const searchParams = new URLSearchParams({ | |
yql: `select * from linqto where id contains "${docId}"`, | |
hits: '1' | |
}); | |
const response = await vespaRequest(`${searchUrl}?${searchParams}`); | |
if (!response.ok) { | |
throw new Error(`Vespa returned ${response.status}`); | |
} | |
const data = await response.json(); | |
if (data.root?.children?.[0]?.fields) { | |
const fields = data.root.children[0].fields; | |
const base64Image = fields.full_image || fields.image; | |
if (base64Image) { | |
const result = { base64_image: base64Image }; | |
cache.set(cacheKey, result, 86400); // 24 hours | |
c.header('X-Cache', 'MISS'); | |
return c.json(result); | |
} | |
} | |
return c.json({ error: 'Image not found' }, 404); | |
} catch (error) { | |
console.error('Full image error:', error); | |
return c.json({ | |
error: 'Failed to fetch image', | |
message: error instanceof Error ? error.message : 'Unknown error' | |
}, 500); | |
} | |
}); | |
// Query suggestions endpoint | |
api.get('/query-suggestions', async (c) => { | |
try { | |
const query = c.req.query('query'); | |
// Static suggestions for now | |
const staticSuggestions = [ | |
'linqto bankruptcy', | |
'linqto filing date', | |
'linqto creditors', | |
'linqto assets', | |
'linqto liabilities', | |
'linqto chapter 11', | |
'linqto docket', | |
'linqto plan', | |
'linqto disclosure statement', | |
'linqto claims', | |
]; | |
if (!query) { | |
return c.json({ suggestions: staticSuggestions.slice(0, 5) }); | |
} | |
const lowerQuery = query.toLowerCase(); | |
const filtered = staticSuggestions | |
.filter(s => s.toLowerCase().includes(lowerQuery)) | |
.slice(0, 5); | |
return c.json({ suggestions: filtered }); | |
} catch (error) { | |
console.error('Suggestions error:', error); | |
return c.json({ | |
error: 'Failed to fetch suggestions', | |
suggestions: [] | |
}, 500); | |
} | |
}); | |
// Similarity maps endpoint (placeholder) | |
api.get('/similarity-maps', async (c) => { | |
try { | |
const queryId = c.req.query('queryId'); | |
const idx = c.req.query('idx'); | |
const token = c.req.query('token'); | |
const tokenIdx = c.req.query('tokenIdx'); | |
if (!queryId || !idx || !token || !tokenIdx) { | |
return c.json({ error: 'Missing required parameters' }, 400); | |
} | |
// Return placeholder HTML | |
const html = ` | |
<div style="padding: 20px; text-align: center;"> | |
<h3>Similarity Map</h3> | |
<p>Query: ${token}</p> | |
<p>Document: ${idx}</p> | |
<p style="color: #666;"> | |
Similarity map generation requires the ColPali model. | |
This is a placeholder for the demo. | |
</p> | |
</div> | |
`; | |
return c.html(html); | |
} catch (error) { | |
console.error('Similarity map error:', error); | |
return c.json({ | |
error: 'Failed to generate similarity map', | |
message: error instanceof Error ? error.message : 'Unknown error' | |
}, 500); | |
} | |
}); | |
// Visual RAG Chat SSE endpoint | |
api.get('/visual-rag-chat', async (c) => { | |
const queryId = c.req.query('queryId'); | |
const query = c.req.query('query'); | |
const docIds = c.req.query('docIds'); | |
if (!queryId || !query || !docIds) { | |
return c.json({ error: 'Missing required parameters: queryId, query, docIds' }, 400); | |
} | |
return streamSSE(c, async (stream) => { | |
try { | |
// Mock response for now - in production this would use an LLM | |
const messages = [ | |
`I'll analyze the search results for your query: "${query}"`, | |
"Based on the documents provided, here are the key findings:", | |
"1. LINQTO filed for Chapter 11 bankruptcy protection", | |
"2. The filing includes detailed financial statements and creditor information", | |
"3. Various claims and assets are documented in the court filings", | |
"", | |
"This is a demo response. In production, this would analyze the actual document contents using an LLM." | |
]; | |
for (const msg of messages) { | |
await stream.writeSSE({ data: msg }); | |
await new Promise(resolve => setTimeout(resolve, 300)); // Simulate typing | |
} | |
} catch (error) { | |
console.error('Chat streaming error:', error); | |
await stream.writeSSE({ | |
event: 'error', | |
data: JSON.stringify({ | |
error: 'Streaming failed', | |
message: error instanceof Error ? error.message : 'Unknown error' | |
}), | |
}); | |
} | |
}); | |
}); | |
export { api }; | |