"""
SPARKNET - AI-Powered Technology Transfer Office (TTO) Automation Platform
A comprehensive Streamlit-based platform for research valorization and IP management:
CORE TTO SCENARIOS:
1. Patent Wake-Up: Transform dormant patents into commercialization opportunities
2. Agreement Safety: AI-assisted legal document review with risk detection
3. Partner Matching: Intelligent stakeholder matching for technology transfer
4. License Compliance Monitoring: Payment tracking, milestone verification, revenue alerts
5. Award Identification: Funding opportunity scanning and nomination assistance
FEATURES:
- Multi-agent AI orchestration with CriticAgent validation
- Document Intelligence with evidence grounding
- RAG-powered search and Q&A with source verification
- Confidence scoring and hallucination mitigation
- Human-in-the-loop decision points
- GDPR-compliant data handling options
VISTA/Horizon EU Project - Supporting European research valorization
"""
import streamlit as st
import sys
import os
from pathlib import Path
import json
import time
from datetime import datetime
# Add project root to path
PROJECT_ROOT = Path(__file__).parent.parent
sys.path.insert(0, str(PROJECT_ROOT))
# Page configuration - MUST be first Streamlit command
st.set_page_config(
page_title="SPARKNET - TTO Automation Platform",
page_icon="π₯",
layout="wide",
initial_sidebar_state="expanded",
menu_items={
'About': "SPARKNET: AI-Powered Technology Transfer Office Automation\n\nVISTA/Horizon EU Project"
}
)
# Authentication - require login before showing app
from auth import check_password, show_logout_button
if not check_password():
st.stop()
# Show logout button in sidebar
show_logout_button()
# Custom CSS
st.markdown("""
""", unsafe_allow_html=True)
def get_sample_documents():
"""Get list of sample documents from Dataset folder."""
dataset_path = PROJECT_ROOT / "Dataset"
if dataset_path.exists():
return sorted([f.name for f in dataset_path.glob("*.pdf")])
return []
def format_confidence(confidence: float) -> str:
"""Format confidence with color coding."""
if confidence >= 0.8:
return f'{confidence:.1%}'
elif confidence >= 0.6:
return f'{confidence:.1%}'
else:
return f'{confidence:.1%}'
def render_critic_validation(validation_result: dict) -> None:
"""
Render CriticAgent validation results in the UI.
Displays validation scores, issues, and suggestions
with clear visual indicators.
"""
overall_score = validation_result.get("overall_score", 0.0)
is_valid = validation_result.get("valid", False)
dimension_scores = validation_result.get("dimension_scores", {})
issues = validation_result.get("issues", [])
suggestions = validation_result.get("suggestions", [])
# Overall validation status
if is_valid and overall_score >= 0.85:
status_class = "validation-pass"
status_icon = "β"
status_text = "Validated"
elif overall_score >= 0.6:
status_class = "validation-warn"
status_icon = "β "
status_text = "Review Recommended"
else:
status_class = "validation-fail"
status_icon = "β"
status_text = "Validation Failed"
st.markdown(f"""
π‘οΈ CriticAgent Validation
{status_icon} {status_text}
Overall Score
{overall_score:.0%}
""", unsafe_allow_html=True)
# Dimension scores
if dimension_scores:
st.markdown("**Quality Dimensions:**")
cols = st.columns(len(dimension_scores))
for i, (dim, score) in enumerate(dimension_scores.items()):
with cols[i]:
st.metric(
dim.replace("_", " ").title(),
f"{score:.0%}",
delta=None,
)
# Issues
if issues:
with st.expander("β οΈ Issues Found", expanded=len(issues) <= 3):
for issue in issues:
st.markdown(f"- {issue}")
# Suggestions
if suggestions:
with st.expander("π‘ Improvement Suggestions"):
for suggestion in suggestions:
st.markdown(f"- {suggestion}")
st.markdown("
", unsafe_allow_html=True)
def render_source_verification(sources: list, claim: str = "") -> None:
"""
Render source verification for hallucination mitigation.
Shows the sources used to generate AI responses with
verification status.
"""
st.markdown("""
π Source Verification
""", unsafe_allow_html=True)
if sources:
verified_count = sum(1 for s in sources if s.get("verified", False))
total_count = len(sources)
st.markdown(f"""
β {verified_count}/{total_count} sources verified
""", unsafe_allow_html=True)
for i, source in enumerate(sources[:5]): # Show top 5 sources
verified = source.get("verified", False)
page = source.get("page", "N/A")
snippet = source.get("snippet", "")[:100]
confidence = source.get("confidence", 0.0)
st.markdown(f"""
[{i+1}] Page {page} | Confidence: {confidence:.0%}
{' β' if verified else ' β '}
"{snippet}..."
""", unsafe_allow_html=True)
else:
st.markdown("""
No source verification available for this response.
""", unsafe_allow_html=True)
st.markdown("
", unsafe_allow_html=True)
def render_human_decision_point(
question: str,
options: list,
ai_recommendation: str = None,
ai_confidence: float = None,
) -> str:
"""
Render a human-in-the-loop decision point.
Shows AI recommendation but requires human approval
for critical decisions.
Returns:
Selected option from human
"""
st.markdown("""
π€ Human Decision Required
""", unsafe_allow_html=True)
st.markdown(f"**{question}**")
if ai_recommendation and ai_confidence:
st.markdown(f"""
AI Recommendation: {ai_recommendation}
(Confidence: {ai_confidence:.0%})
""", unsafe_allow_html=True)
selected = st.radio(
"Your decision:",
options,
label_visibility="collapsed",
key=f"hitl_{hash(question)}",
)
st.markdown("
", unsafe_allow_html=True)
return selected
def render_confidence_indicator(confidence: float, label: str = "Confidence") -> None:
"""
Render a visual confidence indicator.
Shows confidence as a progress bar with color coding.
"""
if confidence >= 0.8:
color = "#22c55e"
status = "High"
elif confidence >= 0.6:
color = "#eab308"
status = "Medium"
else:
color = "#ef4444"
status = "Low"
st.markdown(f"""
{label}
{status} ({confidence:.0%})
""", unsafe_allow_html=True)
def render_header():
"""Render the main header with TTO branding and EU badges."""
col1, col2 = st.columns([3, 1])
with col1:
st.markdown('π₯ SPARKNET
', unsafe_allow_html=True)
st.markdown('', unsafe_allow_html=True)
# EU/VISTA alignment badges
st.markdown('''
VISTA Project
Horizon EU
''', unsafe_allow_html=True)
with col2:
st.markdown('''
''', unsafe_allow_html=True)
def render_sidebar():
"""Render the sidebar with navigation."""
with st.sidebar:
st.markdown("## Navigation")
page = st.radio(
"Select Feature",
[
"π Home",
"π Document Processing",
"π Field Extraction",
"π¬ RAG Q&A",
"π·οΈ Classification",
"π Analytics",
],
label_visibility="collapsed",
)
st.markdown("---")
st.markdown("### System Status")
# Check component status
ollama_status = check_ollama_status()
st.markdown(f"**Ollama:** {'π’ Online' if ollama_status else 'π΄ Offline'}")
chromadb_status = check_chromadb_status()
st.markdown(f"**ChromaDB:** {'π’ Ready' if chromadb_status else 'π΄ Not initialized'}")
st.markdown("---")
st.markdown("### Sample Documents")
docs = get_sample_documents()
st.markdown(f"**Available:** {len(docs)} PDFs")
return page
def check_ollama_status():
"""Check if Ollama is running."""
try:
import httpx
with httpx.Client(timeout=2.0) as client:
resp = client.get("http://localhost:11434/api/tags")
return resp.status_code == 200
except:
return False
def check_chromadb_status():
"""Check if ChromaDB is available."""
try:
import chromadb
return True
except:
return False
def render_home_page():
"""Render the TTO dashboard home page with scenarios and coverage metrics."""
st.markdown("## Technology Transfer Office Dashboard")
st.markdown("""
SPARKNET is a comprehensive **AI-Powered Technology Transfer Office (TTO) Automation Platform**
designed for research valorization and IP management. Built for the VISTA/Horizon EU project,
it combines multi-agent AI orchestration with document intelligence to automate key TTO workflows.
""")
st.markdown("---")
# =========================================================================
# COVERAGE METRICS DASHBOARD
# =========================================================================
st.markdown("### π TTO Task Coverage Dashboard")
col1, col2, col3 = st.columns(3)
with col1:
st.markdown("""
3
Fully Covered
Production-ready scenarios
""", unsafe_allow_html=True)
with col2:
st.markdown("""
5
Partially Covered
In development
""", unsafe_allow_html=True)
with col3:
st.markdown("""
2
Not Covered
Planned for future
""", unsafe_allow_html=True)
st.markdown("---")
# =========================================================================
# CORE TTO SCENARIOS
# =========================================================================
st.markdown("### π― Core TTO Scenarios")
# Fully Covered Scenarios
st.markdown("#### Fully Implemented")
col1, col2, col3 = st.columns(3)
with col1:
st.markdown("""
π‘ Patent Wake-Up
LIVE
Transform dormant patents into commercialization opportunities
Features:
β’ TRL Assessment
β’ Market Analysis
β’ Partner Matching
β’ Valorization Brief Generation
VISTA Aligned
""", unsafe_allow_html=True)
with col2:
st.markdown("""
βοΈ Agreement Safety
LIVE
AI-assisted legal document review with risk detection
Features:
β’ Risk Clause Detection
β’ GDPR Compliance Check
β’ Law 25 Alignment
β’ Remediation Suggestions
GDPR Ready
""", unsafe_allow_html=True)
with col3:
st.markdown("""
π€ Partner Matching
LIVE
Intelligent stakeholder matching for technology transfer
Features:
β’ Multi-criteria Scoring
β’ Geographic Matching
β’ Technical Fit Analysis
β’ Outreach Recommendations
VISTA Aligned
""", unsafe_allow_html=True)
# Partially Covered Scenarios
st.markdown("#### In Development")
col1, col2 = st.columns(2)
with col1:
st.markdown("""
π License Compliance Monitoring
DEV
Track license agreements and ensure compliance
Planned Features:
β’ Payment Tracking & Alerts
β’ Milestone Verification
β’ Revenue Monitoring
β’ Compliance Reporting
""", unsafe_allow_html=True)
with col2:
st.markdown("""
π Award Identification
DEV
Discover funding opportunities and awards
Planned Features:
β’ Opportunity Scanning
β’ Nomination Assistance
β’ Deadline Tracking
β’ Application Support
""", unsafe_allow_html=True)
st.markdown("---")
# =========================================================================
# AI QUALITY ASSURANCE
# =========================================================================
st.markdown("### π‘οΈ AI Quality Assurance")
col1, col2, col3 = st.columns(3)
with col1:
st.markdown("""
π CriticAgent Validation
Every AI output is validated against VISTA quality standards with dimension-based scoring.
""", unsafe_allow_html=True)
with col2:
st.markdown("""
π Confidence Scoring
All extractions include confidence scores with automatic abstention for low-confidence results.
""", unsafe_allow_html=True)
with col3:
st.markdown("""
π€ Human-in-the-Loop
Critical decisions require human approval with clear decision points throughout workflows.
""", unsafe_allow_html=True)
st.markdown("---")
# =========================================================================
# PLATFORM CAPABILITIES
# =========================================================================
st.markdown("### π Platform Capabilities")
col1, col2, col3, col4 = st.columns(4)
with col1:
st.markdown("""
π
Document Intelligence
OCR, Layout, Chunking
""", unsafe_allow_html=True)
with col2:
st.markdown("""
π
Evidence Grounding
Source Verification
""", unsafe_allow_html=True)
with col3:
st.markdown("""
π¬
RAG Q&A
Grounded Citations
""", unsafe_allow_html=True)
with col4:
st.markdown("""
π€
Multi-Agent AI
Orchestrated Workflows
""", unsafe_allow_html=True)
st.markdown("---")
# Quick start
st.markdown("### π Quick Start Guide")
with st.expander("Getting Started with SPARKNET", expanded=True):
st.markdown("""
**For TTO Staff:**
1. **Patent Wake-Up**: Upload a dormant patent to generate a valorization roadmap
2. **Agreement Safety**: Upload contracts/agreements for AI-assisted risk review
3. **Partner Matching**: Find suitable industry partners for your technologies
**For Researchers:**
1. **Document Processing**: Process research documents with OCR and extraction
2. **RAG Q&A**: Ask questions about indexed documents
3. **Evidence Viewer**: Verify AI responses with source grounding
**Sample Documents**: The demo includes patent documents from major tech companies for testing.
""")
# Sample documents preview
st.markdown("### π Sample Documents")
docs = get_sample_documents()
if docs:
cols = st.columns(4)
for i, doc in enumerate(docs[:8]):
with cols[i % 4]:
company = doc.split()[0] if doc else "Unknown"
st.markdown(f"""
π {company}
{doc[:30]}...
""", unsafe_allow_html=True)
def render_document_processing_page():
"""Render the document processing page."""
st.markdown("## π Document Processing Pipeline")
st.markdown("""
Process documents through our intelligent pipeline:
**OCR β Layout Detection β Reading Order β Semantic Chunking β Grounding**
""")
# Document selection
col1, col2 = st.columns([2, 1])
with col1:
upload_option = st.radio(
"Document Source",
["Select from samples", "Upload new document"],
horizontal=True,
)
if upload_option == "Select from samples":
docs = get_sample_documents()
if docs:
selected_doc = st.selectbox("Select a document", docs)
doc_path = PROJECT_ROOT / "Dataset" / selected_doc
else:
st.warning("No sample documents found")
doc_path = None
else:
uploaded_file = st.file_uploader("Upload PDF", type=["pdf"])
if uploaded_file:
# Save temporarily
temp_path = PROJECT_ROOT / "data" / "temp" / uploaded_file.name
temp_path.parent.mkdir(parents=True, exist_ok=True)
with open(temp_path, "wb") as f:
f.write(uploaded_file.read())
doc_path = temp_path
else:
doc_path = None
with col2:
st.markdown("### Processing Options")
ocr_engine = st.selectbox("OCR Engine", ["paddleocr", "tesseract"])
max_pages = st.slider("Max Pages", 1, 20, 5)
render_dpi = st.selectbox("Render DPI", [150, 200, 300], index=2)
st.markdown("---")
if doc_path and st.button("π Process Document", type="primary"):
process_document_demo(doc_path, ocr_engine, max_pages, render_dpi)
def process_document_demo(doc_path, ocr_engine, max_pages, render_dpi):
"""Demo document processing."""
progress_bar = st.progress(0)
status_text = st.empty()
# Simulate processing stages
stages = [
("Loading document...", 0.1),
("Running OCR extraction...", 0.3),
("Detecting layout regions...", 0.5),
("Reconstructing reading order...", 0.7),
("Creating semantic chunks...", 0.9),
("Finalizing...", 1.0),
]
for stage_text, progress in stages:
status_text.text(stage_text)
progress_bar.progress(progress)
time.sleep(0.5)
status_text.text("β
Processing complete!")
# Try actual processing
try:
from src.document.pipeline import process_document, PipelineConfig
from src.document.ocr import OCRConfig
config = PipelineConfig(
ocr=OCRConfig(engine=ocr_engine),
render_dpi=render_dpi,
max_pages=max_pages,
)
with st.spinner("Running actual document processing..."):
result = process_document(str(doc_path), config=config)
# Display results
render_processing_results(result)
except Exception as e:
st.warning(f"Live processing unavailable: {e}")
st.info("Showing demo results instead...")
render_demo_processing_results(str(doc_path))
def render_processing_results(result):
"""Render actual processing results."""
# Metrics
col1, col2, col3, col4 = st.columns(4)
with col1:
st.metric("Pages", result.metadata.num_pages)
with col2:
st.metric("Chunks", result.metadata.total_chunks)
with col3:
st.metric("Characters", f"{result.metadata.total_characters:,}")
with col4:
conf = result.metadata.ocr_confidence_avg or 0
st.metric("OCR Confidence", f"{conf:.1%}")
st.markdown("---")
# Tabs for different views
tab1, tab2, tab3 = st.tabs(["π Extracted Text", "π¦ Chunks", "πΊοΈ Layout"])
with tab1:
st.markdown("### Full Extracted Text")
st.text_area(
"Document Text",
result.full_text[:5000] + "..." if len(result.full_text) > 5000 else result.full_text,
height=400,
)
with tab2:
st.markdown("### Document Chunks")
for i, chunk in enumerate(result.chunks[:10]):
with st.expander(f"Chunk {i+1}: {chunk.chunk_type.value} (Page {chunk.page + 1})"):
st.markdown(f"**ID:** `{chunk.chunk_id}`")
st.markdown(f"**Confidence:** {format_confidence(chunk.confidence)}", unsafe_allow_html=True)
st.markdown(f"**BBox:** ({chunk.bbox.x_min:.0f}, {chunk.bbox.y_min:.0f}) β ({chunk.bbox.x_max:.0f}, {chunk.bbox.y_max:.0f})")
st.markdown("**Text:**")
st.text(chunk.text[:500])
with tab3:
st.markdown("### Layout Regions")
if result.layout_regions:
layout_data = []
for r in result.layout_regions:
layout_data.append({
"Type": r.layout_type.value,
"Page": r.page + 1,
"Confidence": f"{r.confidence:.1%}",
"Position": f"({r.bbox.x_min:.0f}, {r.bbox.y_min:.0f})",
})
st.dataframe(layout_data, width='stretch')
else:
st.info("No layout regions detected")
def render_demo_processing_results(doc_path):
"""Render demo processing results when actual processing unavailable."""
doc_name = Path(doc_path).name
# Simulated metrics
col1, col2, col3, col4 = st.columns(4)
with col1:
st.metric("Pages", 12)
with col2:
st.metric("Chunks", 47)
with col3:
st.metric("Characters", "15,234")
with col4:
st.metric("OCR Confidence", "94.2%")
st.markdown("---")
# Demo chunks
demo_chunks = [
{
"type": "title",
"page": 1,
"confidence": 0.98,
"text": f"PATENT PLEDGE - {doc_name.split()[0]}",
"bbox": "(100, 50) β (700, 100)",
},
{
"type": "text",
"page": 1,
"confidence": 0.95,
"text": "This Patent Pledge is made by the undersigned company to promote innovation and reduce patent-related barriers...",
"bbox": "(100, 150) β (700, 300)",
},
{
"type": "text",
"page": 1,
"confidence": 0.92,
"text": "The company hereby pledges not to assert any patent claims against any party making, using, or selling products...",
"bbox": "(100, 320) β (700, 500)",
},
]
tab1, tab2 = st.tabs(["π Extracted Text", "π¦ Chunks"])
with tab1:
st.markdown("### Full Extracted Text")
demo_text = f"""
PATENT PLEDGE - {doc_name.split()[0]}
This Patent Pledge is made by the undersigned company to promote innovation
and reduce patent-related barriers in the technology industry.
DEFINITIONS:
1. "Covered Patents" means all patents and patent applications owned by
the Pledgor that cover fundamental technologies.
2. "Open Source Software" means software distributed under licenses
approved by the Open Source Initiative.
PLEDGE:
The company hereby pledges not to assert any Covered Patents against
any party making, using, selling, or distributing Open Source Software.
This pledge is irrevocable and shall remain in effect for the life
of all Covered Patents.
[Document continues with legal terms and conditions...]
"""
st.text_area("Document Text", demo_text, height=400)
with tab2:
st.markdown("### Document Chunks")
for i, chunk in enumerate(demo_chunks):
with st.expander(f"Chunk {i+1}: {chunk['type']} (Page {chunk['page']})"):
st.markdown(f"**Confidence:** {format_confidence(chunk['confidence'])}", unsafe_allow_html=True)
st.markdown(f"**BBox:** {chunk['bbox']}")
st.markdown("**Text:**")
st.text(chunk["text"])
def render_extraction_page():
"""Render the field extraction page."""
st.markdown("## π Field Extraction with Evidence")
st.markdown("""
Extract structured fields from documents with **evidence grounding**.
Every extracted value includes its source location (page, bbox, chunk_id).
""")
col1, col2 = st.columns([2, 1])
with col1:
# Document selection
docs = get_sample_documents()
if docs:
selected_doc = st.selectbox("Select Document", docs, key="extract_doc")
st.markdown("### Fields to Extract")
# Predefined schemas
schema_type = st.selectbox(
"Extraction Schema",
["Patent/Legal Document", "Invoice", "Contract", "Custom"],
)
if schema_type == "Patent/Legal Document":
default_fields = ["document_title", "company_name", "effective_date", "key_terms", "parties_involved"]
elif schema_type == "Invoice":
default_fields = ["invoice_number", "date", "total_amount", "vendor_name", "line_items"]
elif schema_type == "Contract":
default_fields = ["contract_title", "parties", "effective_date", "term_length", "key_obligations"]
else:
default_fields = ["field_1", "field_2"]
fields = st.multiselect(
"Select fields to extract",
default_fields,
default=default_fields[:3],
)
with col2:
st.markdown("### Extraction Options")
validate = st.checkbox("Validate with Critic", value=True)
include_evidence = st.checkbox("Include Evidence", value=True)
confidence_threshold = st.slider("Min Confidence", 0.0, 1.0, 0.7)
st.markdown("---")
if fields and st.button("π Extract Fields", type="primary"):
extract_fields_demo(selected_doc, fields, validate, include_evidence)
def extract_fields_demo(doc_name, fields, validate, include_evidence):
"""Demo field extraction."""
with st.spinner("Extracting fields..."):
time.sleep(1.5)
st.success("β
Extraction complete!")
# Demo results
company = doc_name.split()[0] if doc_name else "Company"
demo_extractions = {
"document_title": {
"value": f"{company} Patent Non-Assertion Pledge",
"confidence": 0.96,
"page": 1,
"evidence": f"Found in header: '{company} Patent Non-Assertion Pledge' at position (100, 50)",
},
"company_name": {
"value": company,
"confidence": 0.98,
"page": 1,
"evidence": f"Identified as pledgor: '{company}' mentioned 15 times throughout document",
},
"effective_date": {
"value": doc_name.split()[-1].replace(".pdf", "") if len(doc_name.split()) > 1 else "N/A",
"confidence": 0.85,
"page": 1,
"evidence": "Date found in document header",
},
"key_terms": {
"value": "Patent pledge, Open source, Non-assertion, Royalty-free",
"confidence": 0.89,
"page": 2,
"evidence": "Key terms identified from definitions section",
},
"parties_involved": {
"value": f"{company}, Open Source Community",
"confidence": 0.82,
"page": 1,
"evidence": "Parties identified from pledge declaration",
},
}
# Display results
st.markdown("### Extracted Fields")
for field in fields:
if field in demo_extractions:
data = demo_extractions[field]
col1, col2 = st.columns([3, 1])
with col1:
st.markdown(f"""
{field.replace('_', ' ').title()}
{data['value']}
""", unsafe_allow_html=True)
with col2:
st.markdown(f"**Confidence:** {format_confidence(data['confidence'])}", unsafe_allow_html=True)
st.markdown(f"**Page:** {data['page']}")
if include_evidence:
st.markdown(f"""
π Evidence: {data['evidence']}
""", unsafe_allow_html=True)
st.markdown("")
# Validation results with CriticAgent visibility
if validate:
st.markdown("---")
# Demo validation result from CriticAgent
demo_validation = {
"valid": True,
"overall_score": 0.87,
"dimension_scores": {
"completeness": 0.92,
"clarity": 0.88,
"accuracy": 0.85,
"actionability": 0.82,
},
"issues": [
"Effective date confidence is below threshold (0.85)",
],
"suggestions": [
"Consider manual verification of the effective date",
"Cross-reference parties with external sources",
],
}
render_critic_validation(demo_validation)
# Source verification
demo_sources = [
{"page": 1, "snippet": "PATENT PLEDGE - This Patent Pledge is made by...", "verified": True, "confidence": 0.95},
{"page": 1, "snippet": "The company hereby pledges not to assert...", "verified": True, "confidence": 0.91},
{"page": 2, "snippet": "Covered Patents means all patents...", "verified": True, "confidence": 0.88},
]
render_source_verification(demo_sources, "Patent pledge document analysis")
# Confidence indicator for overall extraction
render_confidence_indicator(0.89, "Extraction Confidence")
def render_rag_page():
"""Render the RAG Q&A page."""
st.markdown("## π¬ RAG Question Answering")
st.markdown("""
Ask questions about indexed documents. Answers include **citations** pointing to
the exact source chunks with page numbers and text snippets.
""")
# Index status
col1, col2 = st.columns([2, 1])
with col1:
st.markdown("### Ask a Question")
# Preset questions
preset_questions = [
"What is the main purpose of this document?",
"What patents are covered by this pledge?",
"What are the key terms and definitions?",
"Who are the parties involved?",
"What are the conditions for the pledge?",
]
question_mode = st.radio(
"Question Mode",
["Select preset", "Custom question"],
horizontal=True,
)
if question_mode == "Select preset":
question = st.selectbox("Select a question", preset_questions)
else:
question = st.text_input("Enter your question")
col_a, col_b = st.columns(2)
with col_a:
top_k = st.slider("Number of sources", 1, 10, 5)
with col_b:
show_confidence = st.checkbox("Show confidence scores", value=True)
with col2:
st.markdown("### Index Status")
st.markdown("""
- **Documents indexed:** 3
- **Total chunks:** 147
- **Embedding model:** nomic-embed-text
- **Vector dimension:** 768
""")
st.markdown("---")
if question and st.button("π Get Answer", type="primary"):
rag_query_demo(question, top_k, show_confidence)
def rag_query_demo(question, top_k, show_confidence):
"""Demo RAG query."""
with st.spinner("Searching documents and generating answer..."):
time.sleep(1.5)
# Demo answer based on question
demo_answers = {
"purpose": {
"answer": "The main purpose of this document is to establish a **Patent Non-Assertion Pledge** where the company commits not to assert certain patent claims against parties using, making, or distributing Open Source Software. This pledge aims to promote innovation and reduce patent-related barriers in the technology industry.",
"confidence": 0.92,
"citations": [
{"index": 1, "page": 1, "snippet": "This Patent Pledge is made to promote innovation and reduce patent-related barriers...", "confidence": 0.95},
{"index": 2, "page": 1, "snippet": "The company hereby pledges not to assert any patent claims against any party...", "confidence": 0.91},
],
},
"patents": {
"answer": "The pledge covers **all patents and patent applications** owned by the Pledgor that relate to fundamental technologies used in Open Source Software. Specifically, these are referred to as 'Covered Patents' in the document, defined as patents that cover essential features or functionalities.",
"confidence": 0.88,
"citations": [
{"index": 1, "page": 2, "snippet": "'Covered Patents' means all patents and patent applications owned by the Pledgor...", "confidence": 0.93},
{"index": 2, "page": 2, "snippet": "Patents covering fundamental technologies essential to Open Source implementations...", "confidence": 0.85},
],
},
"default": {
"answer": "Based on the available documents, this appears to be a **Patent Pledge** document from a major technology company. The document establishes terms for patent non-assertion related to Open Source Software, with specific definitions and conditions outlined in the legal text.",
"confidence": 0.75,
"citations": [
{"index": 1, "page": 1, "snippet": "Patent Pledge document establishing non-assertion terms...", "confidence": 0.80},
],
},
}
# Select answer based on question keywords
if "purpose" in question.lower() or "main" in question.lower():
result = demo_answers["purpose"]
elif "patent" in question.lower() and "cover" in question.lower():
result = demo_answers["patents"]
else:
result = demo_answers["default"]
# Display answer
st.markdown("### Answer")
st.markdown(f"""
{result['answer']}
""", unsafe_allow_html=True)
if show_confidence:
st.markdown(f"**Overall Confidence:** {format_confidence(result['confidence'])}", unsafe_allow_html=True)
# Citations
st.markdown("### π Citations")
for citation in result["citations"][:top_k]:
st.markdown(f"""
[{citation['index']}] Page {citation['page']}
{f' - Confidence: {citation["confidence"]:.0%}' if show_confidence else ''}
"{citation['snippet']}"
""", unsafe_allow_html=True)
def render_classification_page():
"""Render the classification page."""
st.markdown("## π·οΈ Document Classification")
st.markdown("""
Automatically classify documents into predefined categories with confidence scores
and reasoning explanations.
""")
docs = get_sample_documents()
col1, col2 = st.columns([2, 1])
with col1:
if docs:
selected_doc = st.selectbox("Select Document to Classify", docs, key="classify_doc")
st.markdown("### Document Categories")
categories = [
"π Legal/Patent Document",
"π Contract/Agreement",
"π Financial Report",
"π Technical Specification",
"π General Business Document",
]
st.markdown("\n".join([f"- {cat}" for cat in categories]))
with col2:
st.markdown("### Classification Options")
detailed_reasoning = st.checkbox("Show detailed reasoning", value=True)
multi_label = st.checkbox("Allow multiple categories", value=False)
st.markdown("---")
if st.button("π·οΈ Classify Document", type="primary"):
classify_document_demo(selected_doc, detailed_reasoning)
def classify_document_demo(doc_name, detailed_reasoning):
"""Demo document classification."""
with st.spinner("Analyzing document..."):
time.sleep(1.0)
st.success("β
Classification complete!")
# Demo classification results
col1, col2 = st.columns([2, 1])
with col1:
st.markdown("### Primary Classification")
st.markdown("""
π Legal/Patent Document
Patent Non-Assertion Pledge
""", unsafe_allow_html=True)
with col2:
st.markdown("### Confidence Scores")
st.markdown(f"**Legal/Patent:** {format_confidence(0.94)}", unsafe_allow_html=True)
st.markdown(f"**Contract:** {format_confidence(0.72)}", unsafe_allow_html=True)
st.markdown(f"**Technical:** {format_confidence(0.15)}", unsafe_allow_html=True)
st.markdown(f"**Financial:** {format_confidence(0.08)}", unsafe_allow_html=True)
if detailed_reasoning:
st.markdown("---")
st.markdown("### Classification Reasoning")
st.markdown("""
Why Legal/Patent Document?
- Contains legal terminology: "pledge", "assert", "patent claims", "royalty-free"
- Structured as a formal legal declaration
- References specific patent-related definitions
- Contains commitment/obligation language
""", unsafe_allow_html=True)
st.markdown("""
Key Indicators Found:
β’ "Patent Pledge" - Document title indicator (weight: 0.35)
β’ "hereby pledges" - Legal commitment language (weight: 0.25)
β’ "Covered Patents" - Patent-specific terminology (weight: 0.20)
β’ "Open Source Software" - Tech/IP context (weight: 0.15)
""", unsafe_allow_html=True)
def render_analytics_page():
"""Render the analytics page."""
st.markdown("## π Processing Analytics")
st.markdown("View statistics and insights about document processing.")
# Summary metrics
col1, col2, col3, col4 = st.columns(4)
with col1:
st.metric("Documents Processed", 24, delta="+3 today")
with col2:
st.metric("Total Chunks", 1247, delta="+156")
with col3:
st.metric("Avg. Confidence", "91.3%", delta="+2.1%")
with col4:
st.metric("Questions Answered", 89, delta="+12")
st.markdown("---")
# Charts
col1, col2 = st.columns(2)
with col1:
st.markdown("### Document Types Processed")
import pandas as pd
chart_data = pd.DataFrame({
"Type": ["Patent/Legal", "Contract", "Technical", "Financial", "Other"],
"Count": [12, 5, 4, 2, 1],
})
st.bar_chart(chart_data.set_index("Type"))
with col2:
st.markdown("### Processing Performance")
perf_data = pd.DataFrame({
"Stage": ["OCR", "Layout", "Chunking", "Indexing", "Retrieval"],
"Avg Time (s)": [2.3, 0.8, 0.5, 1.2, 0.3],
})
st.bar_chart(perf_data.set_index("Stage"))
st.markdown("---")
# Recent activity
st.markdown("### Recent Activity")
activities = [
{"time": "2 min ago", "action": "Processed", "document": "IBM N_A.pdf", "chunks": 42},
{"time": "15 min ago", "action": "Indexed", "document": "Apple 11.11.2011.pdf", "chunks": 67},
{"time": "1 hour ago", "action": "Queried", "document": "RAG Collection", "chunks": 5},
{"time": "2 hours ago", "action": "Classified", "document": "Google 08.02.2012.pdf", "chunks": 0},
]
for activity in activities:
st.markdown(f"""
{activity['time']} - {activity['action']} {activity['document']}
{f" ({activity['chunks']} chunks)" if activity['chunks'] > 0 else ""}
""", unsafe_allow_html=True)
def main():
"""Main application."""
render_header()
page = render_sidebar()
# Route to appropriate page
if page == "π Home":
render_home_page()
elif page == "π Document Processing":
render_document_processing_page()
elif page == "π Field Extraction":
render_extraction_page()
elif page == "π¬ RAG Q&A":
render_rag_page()
elif page == "π·οΈ Classification":
render_classification_page()
elif page == "π Analytics":
render_analytics_page()
# Footer
st.markdown("---")
st.markdown(
"""
π₯ SPARKNET - AI-Powered Technology Transfer Office Automation Platform
VISTA/Horizon EU Project | Built with Streamlit
VISTA
Horizon EU
""",
unsafe_allow_html=True,
)
if __name__ == "__main__":
main()
