Upload app.py

app.py

@@ -0,0 +1,187 @@
+import os
+import gradio as gr
+from PyPDF2 import PdfReader
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_core.documents import Document
+import chromadb
+from langchain_community.vectorstores import Chroma
+from langchain_nvidia_ai_endpoints import ChatNVIDIA
+from langchain_core.prompts import PromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.pydantic_v1 import BaseModel, Field
+from langgraph.graph import StateGraph, END
+from typing import List, TypedDict
+import pandas as pd
+
+# Set API keys
+os.environ["TAVILY_API_KEY"] = "YOUR_Tavily_API_KEY"
+os.environ["NVIDIA_API_KEY"] = "YOUR_NVIDIA_API_KEY"
+os.environ["LANGCHAIN_PROJECT"] = "RAG Compliance Checker"
+
+# Initialize embedding model
+model_name = "dunzhang/stella_en_1.5B_v5"
+embedding_model = HuggingFaceEmbeddings(
+    model_name=model_name,
+    model_kwargs={'trust_remote_code': True},
+    show_progress=True
+)
+
+# Define data models
+class GradeDocuments(BaseModel):
+    binary_score: str = Field(description="Relevance score 'yes' or 'no'")
+
+class GraphState(TypedDict):
+    question: str
+    generation: str
+    decision: str
+    documents: List[Document]
+
+def create_workflow(retriever):
+    # Define workflow nodes
+    def retrieve(state):
+        print("---RETRIEVING DOCUMENTS---")
+        question = state["question"]
+        documents = retriever.invoke(question)
+        return {"documents": documents, "question": question}
+
+    def grade_documents(state):
+        print("---GRADING DOCUMENTS---")
+        question = state["question"]
+        documents = state["documents"]
+        
+        llm = ChatNVIDIA(model="meta/llama-3.3-70b-instruct")
+        grader = llm.with_structured_output(GradeDocuments)
+        
+        system = """You are a relevance grader. Determine if the document contains
+        information related to the question. Answer 'yes' or 'no'."""
+        prompt = ChatPromptTemplate.from_messages([
+            ("system", system),
+            ("human", "Document:\n{document}\n\nQuestion: {question}")
+        ])
+        
+        filtered_docs = []
+        for doc in documents:
+            response = (prompt | grader).invoke({
+                "question": question,
+                "document": doc.page_content
+            })
+            if response.binary_score == "yes":
+                filtered_docs.append(doc)
+        
+        return {"documents": filtered_docs, "question": question}
+
+    def generate_response(state):
+        print("---GENERATING RESPONSE---")
+        question = state["question"]
+        documents = state["documents"]
+        
+        template = """Answer the question using only the context below:
+        Context: {context}
+        Question: {question}"""
+        
+        prompt = PromptTemplate.from_template(template)
+        llm = ChatNVIDIA(model="meta/llama-3.3-70b-instruct")
+        
+        chain = (
+            {"context": lambda _: "\n\n".join(d.page_content for d in documents), "question": RunnablePassthrough()}
+            | prompt
+            | llm
+            | StrOutputParser()
+        )
+        
+        return {"generation": chain.invoke(question)}
+
+    # Build workflow
+    workflow = StateGraph(GraphState)
+    workflow.add_node("retrieve", retrieve)
+    workflow.add_node("grade", grade_documents)
+    workflow.add_node("generate", generate_response)
+    
+    workflow.add_edge("retrieve", "grade")
+    workflow.add_conditional_edges(
+        "grade",
+        lambda state: "generate" if len(state["documents"]) > 0 else END,
+        {"generate": "generate"}
+    )
+    workflow.add_edge("generate", END)
+    
+    return workflow.compile()
+
+def process_documents(folder_path):
+    """Process PDF files from uploaded folder"""
+    documents = []
+    for filename in os.listdir(folder_path):
+        if filename.endswith(".pdf"):
+            path = os.path.join(folder_path, filename)
+            try:
+                reader = PdfReader(path)
+                text = "\n".join([page.extract_text() for page in reader.pages])
+                documents.append(Document(
+                    page_content=text,
+                    metadata={"source": filename}
+                ))
+            except Exception as e:
+                print(f"Error processing {filename}: {str(e)}")
+    return documents
+
+def analyze_requirements(csv_file, documents):
+    """Main analysis function"""
+    # Create vector store
+    client = chromadb.PersistentClient()
+    vector_store = Chroma(
+        client=client,
+        collection_name="dynamic_rag",
+        embedding_function=embedding_model
+    )
+    
+    # Add documents in batches
+    batch_size = 500
+    for i in range(0, len(documents), batch_size):
+        batch = documents[i:i+batch_size]
+        vector_store.add_documents(batch, ids=[str(n) for n in range(len(batch))])
+    
+    retriever = vector_store.as_retriever(search_kwargs={"k": 5})
+    app = create_workflow(retriever)
+    
+    # Process requirements
+    df = pd.read_csv(csv_file.name)
+    results = []
+    
+    for req in df['Requirement']:
+        response = app.invoke({"question": req})
+        results.append({
+            "Requirement": req,
+            "Response": response["generation"],
+            "Status": "Processed"
+        })
+    
+    return pd.DataFrame(results)
+
+# Gradio interface
+with gr.Blocks(title="RAG Compliance Checker") as interface:
+    gr.Markdown("# AI Compliance Assistant")
+    gr.Markdown("Upload documents and requirements CSV for compliance analysis")
+    
+    with gr.Row():
+        with gr.Column():
+            doc_upload = gr.File(label="Upload Documents Folder", file_count="directory")
+            csv_upload = gr.File(label="Upload Requirements CSV", file_types=[".csv"])
+            submit_btn = gr.Button("Analyze", variant="primary")
+        
+        with gr.Column():
+            results_table = gr.DataFrame(
+                label="Analysis Results",
+                headers=["Requirement", "Response", "Status"],
+                interactive=False
+            )
+            status = gr.Textbox(label="Processing Status")
+    
+    submit_btn.click(
+        fn=lambda doc, csv: analyze_requirements(csv, process_documents(doc)),
+        inputs=[doc_upload, csv_upload],
+        outputs=results_table,
+        api_name="analyze"
+    )
+
+if __name__ == "__main__":
+    interface.launch(server_name="0.0.0.0", server_port=7860, share=True)