Initial FAR Chatbot deployment with LFS

.gitattributes

@@ -0,0 +1 @@
+*.index filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose Streamlit port
+EXPOSE 7860
+
+# Set environment variables
+ENV STREAMLIT_SERVER_PORT=7860
+ENV STREAMLIT_SERVER_ADDRESS=0.0.0.0
+
+# Run Streamlit
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

README.md

@@ -0,0 +1,35 @@
+---
+title: FAR Chatbot
+emoji: 🏛️
+colorFrom: blue
+colorTo: indigo
+sdk: docker
+pinned: false
+license: mit
+---
+
+# 🏛️ FAR Chatbot
+
+An AI-powered assistant for the Federal Acquisition Regulation (FAR).
+
+## Features
+- **RAG-powered answers**: Uses vector search to find relevant FAR sections
+- **Clickable citations**: All FAR references link to acquisition.gov
+- **GPT-4 Turbo**: Generates accurate, well-cited responses
+- **Conversation memory**: Maintains context across questions
+
+## Login
+- Username: `testuser`
+- Password: `farbot2025`
+
+## How It Works
+1. Your question is converted to embeddings
+2. FAISS searches 3,893 FAR sections for relevant content
+3. GPT-4 Turbo generates a response using the actual FAR text
+4. Citations are linked to official acquisition.gov sources
+
+## Built With
+- Sentence Transformers (paraphrase-MiniLM-L6-v2)
+- FAISS vector database
+- OpenAI GPT-4 Turbo
+- Streamlit

app.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+"""
+FAR Chatbot - Hugging Face Spaces Version
+Federal Acquisition Regulation Assistant with Clickable Citations
+"""
+
+import streamlit as st
+import time
+import logging
+import os
+import sys
+import re
+from datetime import datetime
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Import the chatbot
+from far_chatbot import FARChatbot
+
+try:
+    import markdown
+except ImportError:
+    markdown = None
+
+# Configure page
+st.set_page_config(
+    page_title="FAR Chatbot - Federal Acquisition Regulation Assistant",
+    page_icon="🏛️",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Authentication
+VALID_CREDENTIALS = {"testuser": "farbot2025"}
+
+def check_password():
+    def password_entered():
+        username = st.session_state.get("username", "")
+        password = st.session_state.get("password", "")
+        if username in VALID_CREDENTIALS and VALID_CREDENTIALS[username] == password:
+            st.session_state["authenticated"] = True
+            del st.session_state["password"]
+        else:
+            st.session_state["authenticated"] = False
+
+    if "authenticated" not in st.session_state:
+        st.session_state["authenticated"] = False
+
+    if not st.session_state["authenticated"]:
+        col1, col2, col3 = st.columns([1, 2, 1])
+        with col2:
+            st.markdown("## 🏛️ FAR Chatbot Login")
+            st.text_input("Username", key="username")
+            st.text_input("Password", type="password", key="password")
+            st.button("🔐 Log In", on_click=password_entered, type="primary", use_container_width=True)
+            if st.session_state.get("authenticated") == False and "username" in st.session_state and st.session_state["username"]:
+                st.error("❌ Invalid credentials")
+        return False
+    return True
+
+if not check_password():
+    st.stop()
+
+# CSS Styling
+st.markdown("""
+<style>
+    .main-header {
+        text-align: center; padding: 1.5rem;
+        background: linear-gradient(135deg, #1a365d 0%, #2c5282 50%, #2b6cb0 100%);
+        color: white; border-radius: 16px; margin-bottom: 2rem;
+    }
+    .main-header h1 { margin: 0; font-size: 2.5rem; }
+    .main-header p { margin: 0.5rem 0 0 0; opacity: 0.9; }
+    .user-message {
+        background: #f7fafc; padding: 1rem; border-radius: 16px;
+        margin: 1rem 0; border-left: 4px solid #e53e3e;
+    }
+    .bot-message {
+        background: linear-gradient(135deg, #ebf8ff 0%, #e6fffa 100%);
+        padding: 1.25rem; border-radius: 16px; margin: 1rem 0;
+        border-left: 4px solid #2b6cb0;
+    }
+    .citation-link {
+        background: linear-gradient(135deg, #fef3c7 0%, #fde68a 100%);
+        padding: 2px 8px; border-radius: 6px; font-family: monospace;
+        font-weight: 600; color: #92400e; text-decoration: none;
+        border: 1px solid #f59e0b;
+    }
+    .citation-link:hover { background: #fde68a; }
+    .source-card {
+        background: white; border: 1px solid #e2e8f0;
+        border-radius: 12px; padding: 1rem; margin: 0.75rem 0;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Session state
+if 'chatbot' not in st.session_state:
+    st.session_state.chatbot = None
+if 'chat_history' not in st.session_state:
+    st.session_state.chat_history = []
+if 'show_sources' not in st.session_state:
+    st.session_state.show_sources = True
+
+@st.cache_resource
+def load_chatbot():
+    """Load the FAR chatbot"""
+    try:
+        logger.info("Loading FAR Chatbot...")
+        chatbot = FARChatbot(
+            faiss_index_path="data/faiss_index.index",
+            texts_path="data/texts.txt",
+            use_gpt5=True
+        )
+        return chatbot
+    except Exception as e:
+        logger.error(f"Error loading chatbot: {e}")
+        st.error(f"Error loading chatbot: {e}")
+        return None
+
+def get_acquisition_gov_url(citation: str) -> str:
+    base_citation = re.sub(r'\([a-z]\)$', '', citation)
+    return f"https://www.acquisition.gov/far/{base_citation}"
+
+def make_citations_clickable(response: str, search_results: list) -> str:
+    if not markdown:
+        return response
+    
+    text = response
+    
+    def make_link(citation):
+        url = get_acquisition_gov_url(citation)
+        return f'<a href="{url}" target="_blank" class="citation-link">'
+    
+    # Replace citation patterns
+    text = re.sub(r'\[FAR\s+(\d+\.\d+(?:-\d+)?(?:\([a-z]\))?)\]', 
+                  lambda m: f'{make_link(m.group(1))}[{m.group(1)}]</a>', text)
+    text = re.sub(r'\[(\d+\.\d+(?:-\d+)?(?:\([a-z]\))?)\]',
+                  lambda m: f'{make_link(m.group(1))}[{m.group(1)}]</a>', text)
+    text = re.sub(r'(?<!View )FAR\s+(\d+\.\d+(?:-\d+)?(?:\([a-z]\))?)',
+                  lambda m: f'{make_link(m.group(1))}FAR {m.group(1)}</a>', text)
+    
+    return markdown.markdown(text, extensions=['tables', 'fenced_code', 'nl2br'])
+
+# Header
+st.markdown("""
+<div class="main-header">
+    <h1>🏛️ FAR Chatbot</h1>
+    <p>Federal Acquisition Regulation Assistant</p>
+</div>
+""", unsafe_allow_html=True)
+
+# Sidebar
+with st.sidebar:
+    st.markdown("## ⚙️ Settings")
+    
+    if st.session_state.chatbot is None:
+        st.session_state.chatbot = load_chatbot()
+    
+    if st.session_state.chatbot:
+        st.success("✅ Chatbot Ready!")
+    else:
+        st.error("❌ Failed to load")
+    
+    st.session_state.show_sources = st.checkbox("Show sources", value=True)
+    
+    st.markdown("### 💡 Sample Questions")
+    samples = [
+        "What are small business set-asides?",
+        "Explain the simplified acquisition threshold",
+        "What is the micro-purchase threshold?",
+        "When can I use sole source?"
+    ]
+    for q in samples:
+        if st.button(f"💬 {q}", key=f"s_{hash(q)}"):
+            st.session_state.current_question = q
+    
+    if st.button("🗑️ Clear Chat"):
+        st.session_state.chat_history = []
+        st.rerun()
+    
+    if st.button("🚪 Logout"):
+        st.session_state["authenticated"] = False
+        st.rerun()
+
+# Main content
+if st.session_state.chatbot is None:
+    st.error("Chatbot not loaded")
+    st.stop()
+
+# Display chat history
+for entry in st.session_state.chat_history:
+    question, answer, search_results, timestamp = entry[:4]
+    
+    st.markdown(f'<div class="user-message">👤 <b>You:</b> {question}</div>', unsafe_allow_html=True)
+    
+    formatted = make_citations_clickable(answer, search_results)
+    st.markdown(f'<div class="bot-message">🤖 <b>FAR Bot:</b><br>{formatted}</div>', unsafe_allow_html=True)
+    
+    if st.session_state.show_sources and search_results:
+        with st.expander("📚 Sources"):
+            for cit, txt in search_results[:5]:
+                url = get_acquisition_gov_url(cit)
+                st.markdown(f"**[FAR {cit}]({url})**: {txt[:300]}...")
+
+# Input
+st.markdown("## 💬 Ask a Question")
+
+question = ""
+if 'current_question' in st.session_state:
+    question = st.session_state.current_question
+    del st.session_state.current_question
+
+question = st.text_input("Your question:", value=question, placeholder="Ask about FAR regulations...")
+
+if st.button("🚀 Ask", type="primary") and question.strip():
+    with st.spinner("Processing..."):
+        try:
+            result = st.session_state.chatbot.chat(question, top_k=None)
+            
+            timestamp = datetime.now().strftime("%H:%M")
+            st.session_state.chat_history.append((
+                question,
+                result['response'],
+                result.get('search_results', []),
+                timestamp
+            ))
+            st.rerun()
+        except Exception as e:
+            st.error(f"Error: {e}")
+
+st.markdown("---")
+st.markdown("🏛️ FAR Chatbot | Powered by GPT-4 Turbo | [acquisition.gov](https://acquisition.gov)")

data/faiss_index.index

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf2c5198eeb91c146435dc22a65f48f25379238ca3b4a28ce368c1f0a93eab65
+size 5979693

far_chatbot.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+"""
+FAR Chatbot - Simplified version for Hugging Face Spaces
+"""
+
+import os
+import logging
+import numpy as np
+import faiss
+from sentence_transformers import SentenceTransformer
+from openai import OpenAI
+from typing import List, Tuple, Dict, Optional
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class ConversationMemory:
+    """Simple conversation memory"""
+    def __init__(self, max_turns: int = 5):
+        self.history = []
+        self.max_turns = max_turns
+        self.current_topics = []
+    
+    def add_turn(self, question: str, answer: str, topics: List[str] = None):
+        self.history.append({"question": question, "answer": answer})
+        if len(self.history) > self.max_turns:
+            self.history.pop(0)
+        if topics:
+            self.current_topics = topics[:3]
+    
+    def get_context(self) -> str:
+        if not self.history:
+            return ""
+        context = "Previous conversation:\n"
+        for turn in self.history[-3:]:
+            context += f"Q: {turn['question']}\nA: {turn['answer'][:200]}...\n\n"
+        return context
+
+class FARChatbot:
+    """FAR Chatbot with RAG capabilities"""
+    
+    def __init__(self, faiss_index_path: str, texts_path: str, 
+                 model_name: str = 'paraphrase-MiniLM-L6-v2',
+                 openai_api_key: str = None, use_gpt5: bool = True):
+        
+        self.use_gpt5 = use_gpt5
+        logger.info("Loading SentenceTransformer model...")
+        self.model = SentenceTransformer(model_name)
+        logger.info("Model loaded!")
+        
+        # Load FAISS index
+        logger.info(f"Loading FAISS index from {faiss_index_path}")
+        self.faiss_index = faiss.read_index(faiss_index_path)
+        logger.info(f"FAISS index loaded with {self.faiss_index.ntotal} vectors")
+        
+        # Load texts
+        logger.info(f"Loading texts from {texts_path}")
+        with open(texts_path, 'r', encoding='utf-8') as f:
+            self.texts = [line.strip() for line in f if line.strip()]
+        logger.info(f"Loaded {len(self.texts)} text chunks")
+        
+        # OpenAI client
+        api_key = openai_api_key or os.getenv('OPENAI_API_KEY')
+        if not api_key:
+            raise ValueError("OpenAI API key required")
+        self.client = OpenAI(api_key=api_key)
+        
+        self.conversation = ConversationMemory()
+    
+    def search(self, query: str, top_k: int = 10) -> List[Tuple[str, str]]:
+        """Search for relevant FAR sections"""
+        query_embedding = self.model.encode([query])
+        distances, indices = self.faiss_index.search(query_embedding.astype('float32'), top_k)
+        
+        results = []
+        for idx in indices[0]:
+            if 0 <= idx < len(self.texts):
+                text = self.texts[idx]
+                # Extract citation from text
+                citation = "Unknown"
+                if text.startswith("FAR "):
+                    parts = text.split(":", 1)
+                    if len(parts) > 1:
+                        citation = parts[0].replace("FAR ", "").strip()
+                results.append((citation, text))
+        
+        return results
+    
+    def chat(self, question: str, top_k: int = None) -> Dict:
+        """Process a question and return response"""
+        
+        # Determine context size
+        actual_top_k = 50 if self.use_gpt5 else (top_k or 10)
+        
+        # Search for relevant content
+        search_results = self.search(question, top_k=actual_top_k)
+        
+        # Build context
+        context = "\n\n".join([f"[{cit}]: {txt[:800]}" for cit, txt in search_results[:20]])
+        
+        # Get conversation history
+        conv_context = self.conversation.get_context()
+        
+        # Build prompt
+        system_prompt = """You are FAR Bot, an expert assistant for the Federal Acquisition Regulation (FAR).
+
+INSTRUCTIONS:
+1. Answer questions accurately based on the FAR content provided
+2. ALWAYS cite specific FAR sections using [X.XXX] format
+3. Be concise but thorough
+4. If information isn't in the context, say so
+5. Suggest follow-up questions when appropriate"""
+
+        user_prompt = f"""Question: {question}
+
+{conv_context}
+
+Relevant FAR Sections:
+{context}
+
+Provide a clear, well-cited answer:"""
+
+        # Call OpenAI
+        try:
+            response = self.client.chat.completions.create(
+                model="gpt-4-turbo-preview",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                temperature=0.3,
+                max_tokens=1500
+            )
+            answer = response.choices[0].message.content
+        except Exception as e:
+            logger.error(f"OpenAI error: {e}")
+            answer = f"Error generating response: {e}"
+        
+        # Extract topics (simple extraction)
+        topics = []
+        topic_keywords = ["small business", "threshold", "competition", "contract", "bid", "proposal"]
+        for kw in topic_keywords:
+            if kw.lower() in question.lower():
+                topics.append(kw.title())
+        
+        # Update conversation
+        self.conversation.add_turn(question, answer, topics)
+        
+        # Generate suggestions
+        suggestions = [
+            f"What are the exceptions to this rule?",
+            f"Can you provide more details about the thresholds?",
+            f"What documentation is required?"
+        ]
+        
+        return {
+            'response': answer,
+            'suggestions': suggestions[:3],
+            'topics': topics,
+            'sections': [cit for cit, _ in search_results[:5]],
+            'search_results': search_results[:10],
+            'context_size': len(search_results),
+            'model_used': 'gpt-4-turbo'
+        }

requirements.txt

@@ -0,0 +1,6 @@
+sentence-transformers>=2.2.0
+faiss-cpu>=1.7.0
+openai>=1.0.0
+numpy>=1.21.0
+streamlit>=1.28.0
+markdown>=3.4.0