Create app.py

app.py

@@ -0,0 +1,165 @@
+import streamlit as st
+import os
+from groq import Groq
+from transformers import ViTForImageClassification, ViTImageProcessor
+from sentence_transformers import SentenceTransformer
+from PIL import Image
+import torch
+import numpy as np
+from typing import List, Dict
+import faiss
+import json
+
+# Initialize sentence transformer for embeddings
+@st.cache_resource
+def init_embedding_model():
+    return SentenceTransformer('all-MiniLM-L6-v2')
+
+# Initialize Groq client
+@st.cache_resource
+def init_groq_client():
+    return Groq(api_key=os.environ.get("GROQ_API_KEY"))
+
+class RAGSystem:
+    def __init__(self):
+        self.embedding_model = init_embedding_model()
+        self.knowledge_base = self.load_knowledge_base()
+        self.vector_store = self.create_vector_store()
+        
+    def load_knowledge_base(self) -> List[Dict]:
+        """Load and preprocess knowledge base into a list of documents"""
+        kb = {
+            "spalling": [
+                {
+                    "severity": "Critical",
+                    "description": "Severe concrete spalling with exposed reinforcement and section loss",
+                    "repair_method": ["Install temporary support", "Remove deteriorated concrete", "Clean and treat reinforcement"],
+                    "estimated_cost": "Very High ($15,000+)",
+                    "timeframe": "3-4 weeks",
+                    "location": "Primary structural elements",
+                    "required_expertise": "Structural Engineer + Specialist Contractor",
+                    "immediate_action": "Evacuate area, install temporary support, prevent access",
+                    "prevention": "Regular inspections, waterproofing, chloride protection"
+                },
+                # Add other knowledge base entries...
+            ]
+        }
+        
+        # Convert nested knowledge base into flat documents
+        documents = []
+        for category, items in kb.items():
+            for item in items:
+                # Create a text representation of the document
+                doc_text = f"Category: {category}\n"
+                for key, value in item.items():
+                    if isinstance(value, list):
+                        doc_text += f"{key}: {', '.join(value)}\n"
+                    else:
+                        doc_text += f"{key}: {value}\n"
+                documents.append({
+                    "text": doc_text,
+                    "metadata": {"category": category}
+                })
+        
+        return documents
+
+    def create_vector_store(self):
+        """Create FAISS vector store from knowledge base"""
+        # Generate embeddings for all documents
+        texts = [doc["text"] for doc in self.knowledge_base]
+        embeddings = self.embedding_model.encode(texts)
+        
+        # Initialize FAISS index
+        dimension = embeddings.shape[1]
+        index = faiss.IndexFlatL2(dimension)
+        index.add(np.array(embeddings).astype('float32'))
+        
+        return index
+    
+    def get_relevant_context(self, query: str, k: int = 3) -> str:
+        """Retrieve relevant context based on query"""
+        # Generate query embedding
+        query_embedding = self.embedding_model.encode([query])
+        
+        # Search for similar documents
+        D, I = self.vector_store.search(np.array(query_embedding).astype('float32'), k)
+        
+        # Combine relevant documents into context
+        context = "\n\n".join([self.knowledge_base[i]["text"] for i in I[0]])
+        return context
+
+def get_groq_response(query: str, context: str) -> str:
+    """Get response from Groq LLM"""
+    client = init_groq_client()
+    try:
+        prompt = f"""Based on the following context about construction defects, please answer the question.
+
+Context:
+{context}
+
+Question: {query}
+
+Please provide a detailed and specific answer based on the given context."""
+
+        response = client.chat.completions.create(
+            messages=[
+                {
+                    "role": "system",
+                    "content": "You are a construction defect analysis expert. Provide detailed, accurate answers based on the given context."
+                },
+                {
+                    "role": "user",
+                    "content": prompt
+                }
+            ],
+            model="llama-3.3-70b-versatile",
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def main():
+    st.set_page_config(
+        page_title="Construction Defect RAG Analyzer",
+        page_icon="🏗️",
+        layout="wide"
+    )
+
+    st.title("🏗️ Construction Defect RAG Analyzer")
+
+    # Initialize RAG system
+    if 'rag_system' not in st.session_state:
+        st.session_state.rag_system = RAGSystem()
+
+    # File upload for image analysis
+    uploaded_file = st.file_uploader(
+        "Upload a construction image",
+        type=['jpg', 'jpeg', 'png']
+    )
+
+    # Query input
+    user_query = st.text_input("Ask a question about construction defects:")
+
+    if user_query:
+        with st.spinner("Processing query..."):
+            # Get relevant context using RAG
+            context = st.session_state.rag_system.get_relevant_context(user_query)
+            
+            # Debug view of retrieved context
+            if st.checkbox("Show retrieved context"):
+                st.subheader("Retrieved Context")
+                st.text(context)
+            
+            # Get response from Groq
+            st.subheader("AI Assistant Response")
+            response = get_groq_response(user_query, context)
+            st.write(response)
+
+    if uploaded_file:
+        image = Image.open(uploaded_file)
+        st.image(image, caption="Uploaded Image")
+        
+        # Your existing image analysis code here...
+
+if __name__ == "__main__":
+    main()