Initial commit with project files

.gitignore

@@ -0,0 +1,12 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# Environments
+.env
+venv/
+
+# IDE
+.vscode/

agents/demystifier_agent.py

@@ -0,0 +1,123 @@
+# D:\jan-contract\agents\demystifier_agent.py
+
+import os
+from typing import TypedDict, List
+from pydantic import BaseModel, Field
+
+# --- Core LangChain & Document Processing Imports ---
+from langchain_community.document_loaders import PyMuPDFLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import FAISS
+from langchain.prompts import PromptTemplate
+from langchain.schema.runnable import RunnablePassthrough
+from langchain.schema.output_parser import StrOutputParser
+
+# LangGraph Imports
+from langgraph.graph import StateGraph, END, START
+
+# --- Tool and NEW Core Model Loader Imports ---
+from tools.legal_tools import legal_search
+from core_utils.core_model_loaders import load_groq_llm, load_embedding_model
+
+# --- 1. Model and Parser Setup ---
+# Initialize models by calling the backend-safe loader functions
+groq_llm = load_groq_llm()
+embedding_model = load_embedding_model()
+
+# --- Pydantic Models (No Changes) ---
+class ExplainedTerm(BaseModel):
+    term: str = Field(description="The legal term or jargon identified.")
+    explanation: str = Field(description="A simple, plain-English explanation of the term.")
+    resource_link: str = Field(description="A working URL for a resource explaining this term in India.")
+
+class DemystifyReport(BaseModel):
+    summary: str = Field(description="A concise summary of the legal document's purpose and key points.")
+    key_terms: List[ExplainedTerm] = Field(description="A list of the most important explained legal terms.")
+    overall_advice: str = Field(description="A concluding sentence of general advice.")
+
+# --- 2. LangGraph for Document Analysis (No Changes) ---
+class DemystifyState(TypedDict):
+    document_chunks: List[str]
+    summary: str
+    identified_terms: List[str]
+    final_report: DemystifyReport
+
+def summarize_node(state: DemystifyState):
+    """Takes all document chunks and creates a high-level summary."""
+    print("---NODE (Demystify): Generating Summary---")
+    context = "\n\n".join(state["document_chunks"])
+    prompt = f"You are a paralegal expert... Document Content:\n{context}"
+    summary = groq_llm.invoke(prompt).content
+    return {"summary": summary}
+
+def identify_terms_node(state: DemystifyState):
+    """Identifies the most critical and potentially confusing legal terms in the document."""
+    print("---NODE (Demystify): Identifying Key Terms---")
+    context = "\n\n".join(state["document_chunks"])
+    prompt = f"Based on the following legal document, identify the 3-5 most critical legal terms... Document Content:\n{context}"
+    terms_string = groq_llm.invoke(prompt).content
+    identified_terms = [term.strip() for term in terms_string.split(',') if term.strip()]
+    return {"identified_terms": identified_terms}
+
+def generate_report_node(state: DemystifyState):
+    """Combines the summary and terms into a final, structured report with enriched explanations."""
+    print("---NODE (Demystify): Generating Final Report---")
+    explained_terms_list = []
+    document_context = "\n\n".join(state["document_chunks"])
+    for term in state["identified_terms"]:
+        print(f"  - Researching term: {term}")
+        search_results = legal_search.invoke(f"simple explanation of legal term '{term}' in Indian law")
+        prompt = f"""A user is reading a legal document that contains the term "{term}".
+        Overall document context is: {document_context[:2000]}
+        Web search results for "{term}" are: {search_results}
+        Format your response strictly as:
+        Explanation: [Your simple, one-sentence explanation here]
+        URL: [The best, full, working URL from the search results]"""
+        response = groq_llm.invoke(prompt).content
+        try:
+            explanation = response.split("Explanation:")[1].split("URL:")[0].strip()
+            link = response.split("URL:")[-1].strip()
+        except IndexError:
+            explanation = "Could not generate a simple explanation for this term."
+            link = "No link found."
+        explained_terms_list.append(ExplainedTerm(term=term, explanation=explanation, resource_link=link))
+    final_report = DemystifyReport(summary=state["summary"], key_terms=explained_terms_list, overall_advice="This is an automated analysis. For critical matters, please consult with a qualified legal professional.")
+    return {"final_report": final_report}
+
+# Compile the analysis graph
+graph_builder = StateGraph(DemystifyState)
+graph_builder.add_node("summarize", summarize_node)
+graph_builder.add_node("identify_terms", identify_terms_node)
+graph_builder.add_node("generate_report", generate_report_node)
+graph_builder.add_edge(START, "summarize")
+graph_builder.add_edge("summarize", "identify_terms")
+graph_builder.add_edge("identify_terms", "generate_report")
+graph_builder.add_edge("generate_report", END)
+demystifier_agent_graph = graph_builder.compile()
+
+# --- 3. Helper Function to Create the RAG Chain (No Changes) ---
+def create_rag_chain(retriever):
+    """Creates the Q&A chain for the interactive chat."""
+    prompt_template = """You are a helpful assistant... CONTEXT: {context} QUESTION: {question} ANSWER:"""
+    prompt = PromptTemplate.from_template(prompt_template)
+    rag_chain = ({"context": retriever, "question": RunnablePassthrough()} | prompt | groq_llm | StrOutputParser())
+    return rag_chain
+
+# --- 4. The Master "Controller" Function (No Changes) ---
+def process_document_for_demystification(file_path: str):
+    """Loads a PDF, runs the full analysis, creates a RAG chain, and returns both."""
+    print(f"--- Processing document: {file_path} ---")
+    loader = PyMuPDFLoader(file_path)
+    documents = loader.load()
+    splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
+    chunks = splitter.split_documents(documents)
+    print("--- Creating FAISS vector store for Q&A ---")
+    vectorstore = FAISS.from_documents(chunks, embedding=embedding_model)
+    retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
+    rag_chain = create_rag_chain(retriever)
+    print("--- Running analysis graph for the report ---")
+    chunk_contents = [chunk.page_content for chunk in chunks]
+    graph_input = {"document_chunks": chunk_contents}
+    result = demystifier_agent_graph.invoke(graph_input)
+    report = result.get("final_report")
+    return {"report": report, "rag_chain": rag_chain}

agents/legal_agent.py

@@ -0,0 +1,64 @@
+# D:\jan-contract\agents\legal_agent.py
+
+import os
+from langchain.prompts import PromptTemplate
+from langgraph.graph import StateGraph, END
+from typing import List, TypedDict
+from pydantic import BaseModel, Field
+from langchain_core.output_parsers import PydanticOutputParser
+
+# --- Tool and NEW Core Model Loader Imports ---
+from tools.legal_tools import legal_search
+from core_utils.core_model_loaders import load_gemini_llm
+
+# --- Pydantic Models (No Changes) ---
+class LegalTriviaItem(BaseModel):
+    point: str = Field(description="A concise summary of the legal point or right.")
+    explanation: str = Field(description="A brief explanation of what the point means for the user.")
+    source_url: str = Field(description="The full, working URL to the official source or a highly reputable article explaining the law.")
+
+class LegalTriviaOutput(BaseModel):
+    trivia: List[LegalTriviaItem] = Field(description="A list of structured legal trivia items.")
+
+# --- Setup Models and Parsers ---
+parser = PydanticOutputParser(pydantic_object=LegalTriviaOutput)
+
+# --- Initialize the LLM by calling the backend-safe loader function ---
+llm = load_gemini_llm()
+
+# --- LangGraph State (No Changes) ---
+class LegalAgentState(TypedDict):
+    user_request: str
+    legal_doc: str
+    legal_trivia: LegalTriviaOutput
+
+# --- LangGraph Nodes (No Changes) ---
+def generate_legal_doc(state: LegalAgentState):
+    prompt_text = f"Based on the user's request, generate a simple legal document text for an informal agreement in India. Keep it clear and simple.\n\nUser Request: {state['user_request']}"
+    legal_doc_text = llm.invoke(prompt_text).content
+    return {"legal_doc": legal_doc_text}
+
+def get_legal_trivia(state: LegalAgentState):
+    prompt = PromptTemplate(
+        template="""
+        You are a specialized legal assistant for India's informal workforce...
+        User's situation: {user_request}
+        Web search results: {search_results}
+        {format_instructions}
+        """,
+        input_variables=["user_request", "search_results"],
+        partial_variables={"format_instructions": parser.get_format_instructions()},
+    )
+    chain = prompt | llm | parser
+    search_results = legal_search.invoke(state["user_request"])
+    structured_trivia = chain.invoke({"user_request": state["user_request"], "search_results": search_results})
+    return {"legal_trivia": structured_trivia}
+
+# --- Build Graph (No Changes) ---
+workflow = StateGraph(LegalAgentState)
+workflow.add_node("generate_legal_doc", generate_legal_doc)
+workflow.add_node("get_legal_trivia", get_legal_trivia)
+workflow.set_entry_point("generate_legal_doc")
+workflow.add_edge("generate_legal_doc", "get_legal_trivia")
+workflow.add_edge("get_legal_trivia", END)
+legal_agent = workflow.compile()

agents/scheme_chatbot.py

@@ -0,0 +1,51 @@
+# D:\jan-contract\agents\scheme_chatbot.py
+
+import os
+from langchain.prompts import PromptTemplate
+from langchain.schema.runnable import RunnablePassthrough
+from pydantic import BaseModel, Field
+from langchain_core.output_parsers import PydanticOutputParser
+from typing import List
+
+# --- Tool and NEW Core Model Loader Imports ---
+from tools.scheme_tools import scheme_search
+from core_utils.core_model_loaders import load_gemini_llm
+
+# --- Pydantic Models (No Changes) ---
+class GovernmentScheme(BaseModel):
+    scheme_name: str = Field(description="The official name of the government scheme.")
+    description: str = Field(description="A concise summary of the scheme's objectives and benefits.")
+    target_audience: str = Field(description="Who the scheme is intended for (e.g., Women, Farmers, PwD).")
+    official_link: str = Field(description="The full, working URL to the official government scheme page or portal.")
+
+class SchemeOutput(BaseModel):
+    schemes: List[GovernmentScheme] = Field(description="A list of relevant government schemes.")
+
+# --- Setup Models and Parsers ---
+parser = PydanticOutputParser(pydantic_object=SchemeOutput)
+
+# --- Initialize the LLM by calling the backend-safe loader function ---
+llm = load_gemini_llm()
+
+# --- Prompt Template (No Changes) ---
+prompt = PromptTemplate(
+    template="""
+    You are an expert assistant for Indian government schemes...
+    User Profile: {user_profile}
+    Web search results: {search_results}
+    {format_instructions}
+    """,
+    input_variables=["user_profile", "search_results"],
+    partial_variables={"format_instructions": parser.get_format_instructions()},
+)
+
+# --- Build Chain (No Changes) ---
+def get_search_results(query: dict):
+    return scheme_search.invoke(query["user_profile"])
+
+scheme_chatbot = (
+    {"search_results": get_search_results, "user_profile": RunnablePassthrough()}
+    | prompt
+    | llm
+    | parser
+)

components/video_recorder.py

@@ -0,0 +1,86 @@
+# D:\jan-contract\components\video_recorder.py
+
+import os
+import streamlit as st
+import datetime
+import av
+
+from streamlit_webrtc import webrtc_streamer, WebRtcMode
+
+VIDEO_CONSENT_DIR = "video_consents"
+os.makedirs(VIDEO_CONSENT_DIR, exist_ok=True)
+
+def record_consent_video():
+    """
+    Encapsulates the video recording logic using the component's internal state.
+    
+    The video is automatically saved when the user clicks the "STOP" button
+    on the webrtc component.
+    
+    Returns:
+        str | None: The file path of the saved video, or None if not saved yet.
+    """
+    # Instructions for the new, more intuitive workflow
+    st.info("Instructions: Click START, record your consent, then click STOP to finalize.")
+
+    webrtc_ctx = webrtc_streamer(
+        key="video-consent-recorder",
+        mode=WebRtcMode.SENDRECV, # SENDRECV mode is needed for the stop-button-triggered callback
+        media_stream_constraints={"video": True, "audio": True},
+        video_receiver_size=256,
+        async_processing=True,
+    )
+
+    # This block executes ONLY when the component is running (after START is clicked)
+    if webrtc_ctx.state.playing and webrtc_ctx.video_receiver:
+        # Inform the user that recording is in progress
+        st.success("🔴 Recording in progress...")
+        
+        # If the 'frames_buffer' is not in session state, initialize it
+        if "frames_buffer" not in st.session_state:
+            st.session_state.frames_buffer = []
+        
+        # Append each new frame to our session state buffer
+        while True:
+            try:
+                frame = webrtc_ctx.video_receiver.get_frame(timeout=1)
+                st.session_state.frames_buffer.append(frame)
+            except av.error.TimeoutError:
+                break # Break the loop when the stream ends (user clicks STOP)
+
+    # This block executes after the user clicks STOP
+    if not webrtc_ctx.state.playing and st.session_state.get("frames_buffer"):
+        with st.spinner("Saving your recording..."):
+            try:
+                video_frames = st.session_state.frames_buffer
+                
+                # Generate a unique filename
+                timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+                video_filename = os.path.join(VIDEO_CONSENT_DIR, f"consent_{timestamp}.mp4")
+
+                # Use the av library to write the buffered frames to a video file
+                with av.open(video_filename, mode="w") as container:
+                    stream = container.add_stream("libx264", rate=24)
+                    stream.width = video_frames[0].width
+                    stream.height = video_frames[0].height
+                    stream.pix_fmt = "yuv420p"
+
+                    for frame in video_frames:
+                        packet = stream.encode(frame)
+                        container.mux(packet)
+                    
+                    # Flush the stream
+                    packet = stream.encode()
+                    container.mux(packet)
+                
+                # Clear the buffer from session state and return the path
+                st.session_state.frames_buffer = [] 
+                st.session_state.video_filename = video_filename
+                return video_filename
+
+            except Exception as e:
+                st.error(f"An error occurred while saving the video: {e}")
+                st.session_state.frames_buffer = [] # Clear buffer on error
+                return None
+    
+    return None

core_utils/core_model_loaders.py

@@ -0,0 +1,21 @@
+# D:\jan-contract\core_utils\core_model_loaders.py
+
+import os
+from langchain_community.embeddings import FastEmbedEmbeddings
+from langchain_groq import ChatGroq
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+# --- Simple, non-caching functions for the backend ---
+# These can be safely imported by FastAPI or any other backend script.
+
+def load_embedding_model():
+    """Loads the embedding model without any Streamlit dependencies."""
+    return FastEmbedEmbeddings(model_name="BAAI/bge-base-en-v1.5")
+
+def load_groq_llm():
+    """Loads the Groq LLM without any Streamlit dependencies."""
+    return ChatGroq(temperature=0, model="llama3-8b-8192", api_key=os.getenv("GROQ_API_KEY"))
+
+def load_gemini_llm():
+    """Loads the Gemini LLM without any Streamlit dependencies."""
+    return ChatGoogleGenerativeAI(model="gemini-1.5-flash", temperature=0)

jan-contract

@@ -0,0 +1 @@
+Subproject commit 2848b1d403225a405df97356f7f9e4c4a1a727b6

main_fastapi.py

@@ -0,0 +1,133 @@
+# D:\jan-contract\main_fastapi.py
+
+import os
+import uuid
+import tempfile
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+import io
+
+# --- Import all our backend logic and agents ---
+from agents.legal_agent import legal_agent
+from agents.scheme_chatbot import scheme_chatbot
+from agents.demystifier_agent import process_document_for_demystification
+from utils.pdf_generator import generate_formatted_pdf
+
+# --- 1. Initialize FastAPI App ---
+app = FastAPI(
+    title="Jan-Contract API",
+    description="A comprehensive API for generating digital contracts, finding government schemes, and analyzing legal documents for India's informal workforce.",
+    version="1.0.0",
+)
+
+# --- 2. Pydantic Models for Request Bodies ---
+# These models provide automatic data validation and documentation for our API.
+class ContractRequest(BaseModel):
+    user_request: str
+
+class SchemeRequest(BaseModel):
+    user_profile: str
+
+class ChatRequest(BaseModel):
+    session_id: str
+    question: str
+
+# --- 3. State Management for the Demystifier Chat ---
+# This is a simple in-memory cache for a hackathon. For production, you would
+# use a more robust cache like Redis.
+SESSION_CACHE = {}
+
+# --- 4. API Endpoints ---
+
+@app.post("/generate-contract/json", tags=["Contract Generator"])
+async def generate_contract_json(request: ContractRequest):
+    """
+    Takes a plain-text description and returns a structured JSON object
+    containing the generated contract text (in Markdown) and relevant legal trivia.
+    """
+    try:
+        result = legal_agent.invoke({"user_request": request.user_request})
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"An error occurred: {e}")
+
+@app.post("/generate-contract/pdf", tags=["Contract Generator"])
+async def generate_contract_pdf(request: ContractRequest):
+    """
+    Takes a plain-text description, generates a contract, and returns it
+    directly as a downloadable PDF file.
+    """
+    try:
+        result = legal_agent.invoke({"user_request": request.user_request})
+        contract_text = result.get('legal_doc', "Error: Could not generate document text.")
+        
+        pdf_bytes = generate_formatted_pdf(contract_text)
+        
+        return StreamingResponse(
+            io.BytesIO(pdf_bytes),
+            media_type="application/pdf",
+            headers={"Content-Disposition": "attachment;filename=digital_agreement.pdf"}
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"An error occurred: {e}")
+
+@app.post("/find-schemes", tags=["Scheme Finder"])
+async def find_schemes(request: SchemeRequest):
+    """
+    Takes a user profile description and returns a list of relevant
+    government schemes with names, descriptions, and official links.
+    """
+    try:
+        response = scheme_chatbot.invoke({"user_profile": request.user_profile})
+        return response
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"An error occurred: {e}")
+
+@app.post("/demystify/upload", tags=["Document Demystifier"])
+async def demystify_upload(file: UploadFile = File(...)):
+    """
+    Upload a PDF document for analysis. This endpoint processes the document,
+    creates a RAG chain for chatting, and returns the initial analysis report
+    along with a unique `session_id` for follow-up questions.
+    """
+    if file.content_type != "application/pdf":
+        raise HTTPException(status_code=400, detail="Invalid file type. Please upload a PDF.")
+
+    try:
+        # Use a temporary file to save the upload, as our loader needs a file path
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
+            tmp.write(await file.read())
+            tmp_path = tmp.name
+        
+        analysis_result = process_document_for_demystification(tmp_path)
+        
+        # Clean up the temporary file
+        os.unlink(tmp_path)
+
+        # Create a unique session ID and cache the RAG chain
+        session_id = str(uuid.uuid4())
+        SESSION_CACHE[session_id] = analysis_result["rag_chain"]
+
+        return {
+            "session_id": session_id,
+            "report": analysis_result["report"]
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to process document: {e}")
+
+@app.post("/demystify/chat", tags=["Document Demystifier"])
+async def demystify_chat(request: ChatRequest):
+    """
+    Ask a follow-up question to a previously uploaded document.
+    Requires the `session_id` returned by the /demystify/upload endpoint.
+    """
+    rag_chain = SESSION_CACHE.get(request.session_id)
+    if not rag_chain:
+        raise HTTPException(status_code=404, detail="Session not found. Please upload the document again.")
+    
+    try:
+        response = rag_chain.invoke(request.question)
+        return {"answer": response}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"An error occurred during chat: {e}")

main_streamlit.py

@@ -0,0 +1,164 @@
+# D:\jan-contract\main_streamlit.py
+
+import os
+import streamlit as st
+from dotenv import load_dotenv
+
+from agents.demystifier_agent import process_document_for_demystification
+from components.video_recorder import record_consent_video
+from utils.pdf_generator import generate_formatted_pdf
+
+# --- Initial Setup ---
+load_dotenv()
+st.set_page_config(layout="wide", page_title="Jan-Contract Unified Assistant")
+st.title("Jan-Contract: Your Digital Workforce Assistant")
+
+PDF_UPLOAD_DIR = "pdfs_demystify"
+os.makedirs(PDF_UPLOAD_DIR, exist_ok=True)
+
+# --- Tabs ---
+tab1, tab2, tab3 = st.tabs([
+    " **Contract Generator**", 
+    " **Scheme Finder**", 
+    " **Document Demystifier & Chat**"
+])
+
+# --- TAB 1: Contract Generator ---
+with tab1:
+    st.header("Create a Simple Digital Agreement")
+    st.write("Turn your everyday language into a clear agreement, then provide video consent.")
+    
+    st.subheader("Step 1: Describe and Generate Your Agreement")
+    user_request = st.text_area("Describe the agreement...", height=120, key="contract_request")
+    
+    if st.button("Generate Document & Get Legal Info", type="primary"):
+        if user_request:
+            with st.spinner("Generating document..."):
+                from agents.legal_agent import legal_agent
+                result = legal_agent.invoke({"user_request": user_request})
+                st.session_state.legal_result = result
+                # Reset video state for each new contract
+                if 'video_path_from_component' in st.session_state:
+                    del st.session_state['video_path_from_component']
+                if 'frames_buffer' in st.session_state:
+                    del st.session_state['frames_buffer'] # Clear old frames
+        else:
+            st.error("Please describe the agreement.")
+    
+    if 'legal_result' in st.session_state:
+        result = st.session_state.legal_result
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.subheader("Generated Digital Agreement")
+            st.markdown(result['legal_doc'])
+            pdf_bytes = generate_formatted_pdf(result['legal_doc'])
+            st.download_button(label="⬇️ Download Formatted PDF", data=pdf_bytes, file_name="agreement.pdf")
+        
+        with col2:
+            st.subheader("Relevant Legal Trivia")
+            # ... [Trivia display logic] ...
+
+        st.divider()
+        
+        st.subheader("Step 2: Record Video Consent for this Agreement")
+        saved_video_path = record_consent_video()
+
+        if saved_video_path:
+            st.session_state.video_path_from_component = saved_video_path
+
+        if st.session_state.get("video_path_from_component"):
+            st.success("✅ Your consent has been recorded and saved!")
+            st.video(st.session_state.video_path_from_component)
+            st.info("This video is now linked to your generated agreement.")
+# --- TAB 2: Scheme Finder (Unchanged) ---
+with tab2:
+    st.header("Find Relevant Government Schemes")
+    st.write("Describe yourself or your situation to find government schemes that might apply to you.")
+    
+    user_profile = st.text_input("Enter your profile...", key="scheme_profile")
+    
+    if st.button("Find Schemes", type="primary", key="b2"):
+        if user_profile:
+            with st.spinner("Initializing models and searching for schemes..."):
+                # Lazy import the agent
+                from agents.scheme_chatbot import scheme_chatbot
+                response = scheme_chatbot.invoke({"user_profile": user_profile})
+                st.session_state.scheme_response = response
+        else:
+            st.error("Please enter a profile.")
+            
+    if 'scheme_response' in st.session_state:
+        response = st.session_state.scheme_response
+        st.subheader(f"Potential Schemes for: '{user_profile}'")
+        if response and response.schemes:
+            for scheme in response.schemes:
+                with st.container(border=True):
+                    st.markdown(f"#### {scheme.scheme_name}")
+                    st.write(f"**Description:** {scheme.description}")
+                    st.link_button("Go to Official Page ➡️", scheme.official_link)
+
+# --- TAB 3: Demystifier & Chat (RESTORED to original functionality) ---
+with tab3:
+    st.header("Simplify & Chat With Your Legal Document")
+    st.markdown("Get a plain-English summary of your document, then ask specific follow-up questions.")
+
+    uploaded_file = st.file_uploader("Choose a PDF document", type="pdf", key="demystify_uploader")
+
+    if uploaded_file and st.button("Analyze Document", type="primary"):
+        with st.spinner("Performing deep analysis and preparing for chat..."):
+            # Save the file to a persistent location
+            temp_file_path = os.path.join(PDF_UPLOAD_DIR, uploaded_file.name)
+            with open(temp_file_path, "wb") as f:
+                f.write(uploaded_file.getbuffer())
+            
+            # Single call to the backend agent logic
+            analysis_result = process_document_for_demystification(temp_file_path)
+            
+            # Store the results returned by the agent
+            st.session_state.demystify_report = analysis_result["report"]
+            st.session_state.rag_chain = analysis_result["rag_chain"]
+            st.session_state.messages = [] # Initialize chat history
+
+    # This part of the UI only displays after the analysis is complete
+    if 'demystify_report' in st.session_state:
+        # Step 1: Display Report
+        report = st.session_state.demystify_report
+        st.divider()
+        st.header("Step 1: Automated Document Analysis")
+        with st.container(border=True):
+            st.subheader("📄 Document Summary")
+            st.write(report.summary)
+            st.divider()
+            st.subheader("🔑 Key Terms Explained")
+            for term in report.key_terms:
+                with st.expander(f"**{term.term}**"):
+                    st.write(term.explanation)
+                    st.markdown(f"[Learn More Here]({term.resource_link})")
+            st.divider()
+            st.success(f"**Overall Advice:** {report.overall_advice}")
+        st.divider()
+
+        # Step 2: Display Chat
+        st.header("Step 2: Ask Follow-up Questions")
+        st.info("The document is now ready for your questions. Chat with it below.")
+
+        for message in st.session_state.get("messages", []):
+            with st.chat_message(message["role"]):
+                st.markdown(message["content"])
+
+        if prompt := st.chat_input("Ask a specific question about the document..."):
+            st.session_state.messages.append({"role": "user", "content": prompt})
+            with st.chat_message("user"):
+                st.markdown(prompt)
+
+            with st.chat_message("assistant"):
+                with st.spinner("Searching the document..."):
+                    rag_chain = st.session_state.rag_chain
+                    response = rag_chain.invoke(prompt)
+                    st.markdown(response)
+            
+            st.session_state.messages.append({"role": "assistant", "content": response})
+
+    elif not uploaded_file:
+        st.info("Upload a PDF document to begin the analysis.")

requirements.txt

@@ -0,0 +1,33 @@
+# D:\jan-contract\requirements.txt
+
+# Core LangChain libraries
+langchain-core
+langchain
+langchain-community
+langgraph
+
+# LLM Integrations
+langchain_google_genai
+langchain-groq
+
+# Tooling
+tavily-python
+pypdf
+pymupdf
+fastembed
+faiss-cpu
+python-multipart
+# Web Frameworks
+fastapi
+uvicorn
+streamlit
+
+# Utilities
+python-dotenv
+pydantic
+fpdf2
+
+# --- NEW: For Video Recording ---
+streamlit-webrtc
+opencv-python-headless
+av

tools/legal_tools.py

@@ -0,0 +1,20 @@
+# D:\jan-contract\tools\legal_tools.py
+
+import os
+from dotenv import load_dotenv
+from langchain.tools import tool
+from langchain_community.tools.tavily_search import TavilySearchResults
+
+load_dotenv()
+os.environ["TAVILY_API_KEY"] = os.getenv("TAVILY_API_KEY")
+
+@tool
+def legal_search(query: str):
+    """
+    Searches for legal information and relevant sections for a given query in the Indian context.
+    Use this tool to find legal trivia and sections related to agreements.
+    """
+    # Increased max_results to 5 for more comprehensive context
+    tavily_search = TavilySearchResults(max_results=5)
+    results = tavily_search.invoke(f"Indian law and sections for: {query}")
+    return results

tools/scheme_tools.py

@@ -0,0 +1,20 @@
+# D:\jan-contract\tools\scheme_tools.py
+
+import os
+from dotenv import load_dotenv
+from langchain.tools import tool
+from langchain_community.tools.tavily_search import TavilySearchResults
+
+load_dotenv()
+os.environ["TAVILY_API_KEY"] = os.getenv("TAVILY_API_KEY")
+
+@tool
+def scheme_search(query: str):
+    """
+    Searches for government schemes based on a user's profile.
+    Use this tool to find relevant government schemes for a user.
+    """
+    # Increased max_results to 7 to find content from more sources
+    tavily_search = TavilySearchResults(max_results=7)
+    results = tavily_search.invoke(f"official government schemes for {query} in India site:gov.in OR site:nic.in")
+    return results

utils/model_loaders.py

@@ -0,0 +1,22 @@
+# D:\jan-contract\utils\model_loaders.py
+
+import streamlit as st
+# Import from our new backend-safe loader
+from core_utils.core_model_loaders import load_embedding_model, load_groq_llm, load_gemini_llm
+
+@st.cache_resource
+def get_embedding_model():
+    """Loads and caches the embedding model for the Streamlit app."""
+    with st.spinner("Initializing embedding model (this is a one-time download)..."):
+        model = load_embedding_model()
+    return model
+
+@st.cache_resource
+def get_groq_llm():
+    """Loads and caches the Groq LLM for the Streamlit app."""
+    return load_groq_llm()
+
+@st.cache_resource
+def get_gemini_llm():
+    """Loads and caches the Gemini LLM for the Streamlit app."""
+    return load_gemini_llm()

utils/pdf_generator.py

@@ -0,0 +1,43 @@
+# D:\jan-contract\utils\pdf_generator.py
+
+import re
+from fpdf import FPDF
+
+def markdown_to_html_for_fpdf(md_text: str) -> str:
+    """
+    A helper function to convert our simple Markdown (bold and newlines) 
+    into simple HTML that FPDF's write_html method can understand.
+    """
+    # 1. Convert **bold** syntax to <b>bold</b> HTML tags
+    # The regex finds text between double asterisks and wraps it in <b> tags.
+    text = re.sub(r'\*\*(.*?)\*\*', r'<b>\1</b>', md_text)
+    
+    # 2. Convert newline characters to <br> HTML tags for line breaks
+    text = text.replace('\n', '<br>')
+    
+    return text
+
+def generate_formatted_pdf(text: str) -> bytes:
+    """
+    Takes a string containing Markdown and converts it into a well-formatted PDF
+    by first converting the Markdown to HTML and then rendering the HTML.
+    
+    Args:
+        text (str): The content of the contract, with Markdown syntax.
+        
+    Returns:
+        bytes: The content of the generated PDF file as a byte string.
+    """
+    pdf = FPDF()
+    pdf.add_page()
+    pdf.set_font("Arial", size=12)
+    
+    # Convert our Markdown-style text into simple HTML
+    html_content = markdown_to_html_for_fpdf(text)
+    
+    # Use the more robust write_html() method to render the formatted text.
+    # We still need to handle character encoding properly.
+    pdf.write_html(html_content.encode('latin-1', 'replace').decode('latin-1'))
+    
+    # Return the PDF as a 'bytes' object, which Streamlit requires.
+    return bytes(pdf.output())