Upload 45 files

AI_core/.env

@@ -0,0 +1 @@
+GROQ_API_KEY = "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"

AI_core/__init__.py

@@ -0,0 +1,3 @@
+"""
+AI Core package initialization.
+"""

AI_core/agent/__init__.py

@@ -0,0 +1,6 @@
+"""
+Agent package initialization.
+"""
+from .agent_setup import agent_executor
+
+__all__ = ['agent_executor']

AI_core/agent/agent_setup.py

@@ -0,0 +1,40 @@
+"""
+Setup for the legal assistant agent.
+"""
+from langchain.agents import AgentExecutor, create_tool_calling_agent
+from langchain.prompts import ChatPromptTemplate
+
+from AI_core.config import AGENT_LLM
+from AI_core.tools import tools
+
+# Create the main legal assistant agent
+system_prompt = """
+You are a helpful assistant that can use multiple tools to answer questions. 
+You have access to multiple specialized tools:
+
+1. Document Summarization - For summarizing legal documents
+2. Case Report Generation - For creating comprehensive legal case reports
+3. Evidence Analysis - For analyzing legal evidence using advanced research capabilities 
+   (Use this tool when you need updated information regarding laws and public information)
+4. Legal Q&A - For answering legal questions using a knowledge base
+5. Legal Element Extraction - For extracting specific elements from legal texts
+"""
+
+agent_prompt = ChatPromptTemplate.from_messages(
+    [
+        ("system", system_prompt),
+        ("human", "{input}"),
+        ("placeholder", "{agent_scratchpad}"),
+    ]
+)
+
+agent = create_tool_calling_agent(AGENT_LLM, tools, agent_prompt)
+
+# Create agent executor
+agent_executor = AgentExecutor(
+    agent=agent,
+    tools=tools,
+    verbose=True,
+    handle_parsing_errors=True,
+    max_iterations=5
+)

AI_core/config.py

@@ -0,0 +1,28 @@
+"""
+Configuration settings for the Legal AI Assistant.
+"""
+from dotenv import load_dotenv
+load_dotenv()  # by default looks for .env in current directory
+
+import os
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain_groq import ChatGroq
+
+# LLM configurations
+LLM = ChatGroq(temperature=0, model_name="compound-beta")
+AGENT_LLM = ChatGroq(temperature=0, model_name="deepseek-r1-distill-llama-70b")
+
+# Embedding configuration
+EMBEDDINGS = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+
+# Text splitting configuration
+TEXT_SPLITTER = RecursiveCharacterTextSplitter(
+    chunk_size=1500,
+    chunk_overlap=150,
+)
+
+# API endpoints
+DEEPSEARCH_API_URL = 'https://deepsearch.jina.ai/v1/chat/completions'
+
+

AI_core/main.py

@@ -0,0 +1,25 @@
+"""
+Main entry point for the Legal AI Assistant.
+"""
+import asyncio
+from typing import Dict, Any
+from AI_core.agent import agent_executor
+
+
+
+async def process_legal_request(user_query: str) -> str:
+    """
+    Process a user's legal request using the multiagent system.
+    
+    Args:
+        user_query (str): The user's legal question or request
+        
+    Returns:
+        str: The response from the legal assistant
+    """
+    try:
+        input_data = {"input": user_query}
+        response = await agent_executor.ainvoke(input_data)
+        return response["output"]
+    except Exception as e:
+        return f"Error processing your request: {str(e)}"

AI_core/models/input_schemas.py

@@ -0,0 +1,11 @@
+"""
+Pydantic models for input validation.
+"""
+from pydantic import BaseModel, Field
+
+class ReportGenerationInput(BaseModel):
+    """Input schema for the report generation tool."""
+    case_name: str = Field(description="Name of the legal case")
+    case_facts: str = Field(description="Key facts of the case")
+    legal_issues: str = Field(description="Legal issues identified in the case")
+    applicable_laws: str = Field(description="Laws and regulations applicable to this case")

AI_core/requirement.txt

@@ -0,0 +1,10 @@
+langchain>=0.1.0
+langchain-google-genai>=0.0.5
+google-generativeai>=0.3.0
+langchain-community>=0.0.16
+faiss-cpu>=1.7.4
+pypdf>=3.17.0
+sentence-transformers>=2.5.0
+pydantic>=2.5.0
+requests>=2.31.0
+huggingface-hub>=0.20.0

AI_core/res.md

@@ -0,0 +1,46 @@
+The Affordable Care Act's (ACA) individual mandate has been a lightning rod for legal challenges, primarily questioning the scope of federal power over individual healthcare decisions. The central issue revolves around whether the government can compel individuals to purchase health insurance and the legal justifications for such a mandate.
+
+Initially, opponents of the ACA argued that the individual mandate exceeded Congress's authority under the Commerce Clause of the U.[^1]S. Constitution. This clause grants Congress the power to regulate interstate commerce, but critics contended that it does not extend to compelling individuals to participate in commerce by purchasing health insurance. Several lawsuits were filed challenging the mandate on these grounds, arguing that it represented an unprecedented expansion of federal power. For instance, in *Virginia ex rel. Cuccinelli v. Sebelius*, the plaintiffs argued that the Commerce Clause could not be used to regulate inactivity, i.e., the decision not to purchase health insurance. This argument posited that the Commerce Clause only applies to individuals and entities engaged in an "activity," and because the plaintiffs maintained they were not engaging in any activity, the Commerce Clause did not apply.[^2]
+
+However, in the landmark case of *National Federation of Independent Business (NFIB) v. Sebelius* (2012), the Supreme Court rejected the Commerce Clause argument. Chief Justice John Roberts, writing for the majority, held that the individual mandate could not be justified under the Commerce Clause because it sought to regulate inactivity rather than activity. The Court reasoned that the power to regulate commerce presupposes the existence of commerce to regulate. Mandating the purchase of health insurance, the Court said, was not a permissible regulation of existing commercial activity.
+
+Despite rejecting the Commerce Clause justification, the Supreme Court upheld the individual mandate as a valid exercise of Congress's taxing power. The Court reasoned that the mandate could be interpreted as a tax on those who choose not to purchase health insurance, and that Congress has broad authority to levy taxes under Article I, Section 8 of the Constitution. This decision was pivotal, as it shifted the legal basis for the mandate from the Commerce Clause to the taxing power. The Court emphasized that while Congress could not compel individuals to purchase insurance under the Commerce Clause, it could impose a tax on those who choose not to do so.[^3]
+
+A seismic shift in the legal landscape occurred with the passage of the Tax Cuts and Jobs Act of 2017. This legislation reduced the tax penalty associated with the individual mandate to zero, effectively nullifying its financial impact. While the mandate itself remained on the books, its enforceability was fundamentally undermined. This 'zeroing out' of the penalty triggered a new wave of legal challenges, this time focusing on the severability of the mandate from the rest of the ACA.[^4]
+
+Following the 'zeroing out,' the legal battleground shifted to the doctrine of severability. This doctrine addresses the question of whether, if one provision of a statute is found unconstitutional, the remaining provisions can stand independently. Opponents of the ACA argued that because the individual mandate was now essentially unenforceable, it was no longer constitutional, and that the rest of the ACA could not survive without it. They contended that the mandate was an integral part of the ACA, essential to its functioning, and that Congress would not have enacted the ACA without the mandate in place. This argument was central to the case of *Texas v. United States*, where the plaintiffs argued that the ACA was inextricably linked to the individual mandate, and that the entire law should be struck down.[^5]
+
+Conversely, those defending the ACA argued that the mandate was severable from the rest of the law. They emphasized that Congress's decision to leave the ACA intact when it zeroed out the penalty indicated that the mandate was not so essential that the entire law had to fall with it. They also pointed to the continued stability of the insurance markets after the penalty was reduced to zero as evidence that the ACA could function effectively without the mandate. [^6]This position was supported by numerous legal scholars who argued that the ACA's other provisions, such as the guaranteed issue and community rating requirements, could operate independently of the mandate.
+
+However, these post-'zeroing out' legal challenges encountered a significant obstacle: standing. Standing is a legal doctrine that requires plaintiffs to demonstrate a concrete and particularized injury in order to bring a lawsuit. In *California v. Texas* (2021), the Supreme Court ultimately rejected the challenges to the ACA on standing grounds. The Court held that the plaintiffs, a group of states and individuals, had failed to demonstrate that they had suffered any actual harm as a result of the individual mandate now that the penalty was zero. Chief Justice Roberts, again writing for the majority, reasoned that because individuals were no longer required to pay a penalty for failing to obtain health insurance, they could not show any direct injury caused by the mandate itself. This ruling effectively prevented the Court from reaching the merits of the severability arguments, leaving the ACA intact.
+
+It is also important to acknowledge the dissenting voices in these legal battles. In *NFIB v. Sebelius*, Justices Scalia, Kennedy, Thomas, and Alito dissented, arguing that the individual mandate was unconstitutional under both the Commerce Clause and the Necessary and Proper Clause. They asserted that the mandate exceeded Congress's enumerated powers and could not be justified as a valid exercise of federal authority. Their dissenting opinion reflected a fundamental disagreement with the majority's interpretation of the Constitution and the scope of federal power.
+
+Furthermore, even after the Supreme Court's decision in *California v. Texas*, differing opinions persisted among the lower courts regarding the severability of the individual mandate. For example, the Fifth Circuit Court of Appeals had previously expressed skepticism about the ACA's viability without the mandate, creating a split of authority among the circuit courts. This divergence of opinion underscored the ongoing legal uncertainty surrounding the ACA and the individual mandate.
+
+The following table summarizes the legal arguments, constitutional bases, outcomes, and courts involved in the challenges to the ACA individual mandate:
+
+| Legal Argument | Constitutional Basis | Outcome | Court |
+| --- | --- | --- | --- |
+| Exceeds Congress's power to regulate commerce | Commerce Clause | Rejected | Supreme Court (*NFIB v. Sebelius*) |
+| Unconstitutional as a mandate, but valid as a tax | Taxing Power | Upheld | Supreme Court (*NFIB v. Sebelius*) |
+| Individual mandate is inseverable from the ACA after penalty zeroed out | Severability Doctrine | Challenges rejected on standing grounds | Supreme Court (*California v. Texas*)[^7] |
+
+
+The legal saga surrounding the ACA's individual mandate reveals a complex interplay of constitutional principles, political considerations, and practical implications. While the Supreme Court has twice upheld the ACA, the legal challenges have exposed deep divisions over the role of the federal government in healthcare and the limits of congressional power. The 'zeroing out' of the penalty and the subsequent focus on severability demonstrate how legislative actions can reshape the legal landscape and prompt new rounds of litigation. The ultimate resolution of these challenges underscores the importance of standing as a gatekeeping mechanism in federal courts, preventing abstract legal questions from being decided without a concrete injury. The ACA's journey through the courts serves as a potent reminder of the enduring tension between individual liberty and the collective good, and the ongoing debate over the appropriate balance between the two. The fact that the ACA remains, despite numerous attempts to dismantle it, suggests a certain resilience, perhaps even a recognition of its necessity in the current American healthcare landscape. Or perhaps it simply highlights the inertia of large, complex systems, and the difficulty of unwinding them once they are in place.
+
+
+
+[^1]: States that challenged the ACA argued that the individual mandate was an overreach of Congress s commerce clause powers the government s well recognized but [The Constitutionality of the Affordable Care Act: An Update](https://journalofethics.ama-assn.org/article/constitutionality-affordable-care-act-update/2012-11)
+
+[^2]: But while the Congress that passed the ACA said the mandate was important for the reformed insurance market to function the Congress that zeroed out the penalty decided to keep the other provisions in place Long standing legal principles say that Congress not the court gets to make that decision as even a brief from past litigants against the ACA noted [ACA Survives Legal Challenge, Protecting Coverage for Tens of](https://cbpp.org/research/health/suit-challenging-aca-legally-suspect-but-threatens-loss-of-coverage-for-millions)
+
+[^3]: individual mandate penalty was zeroed out by tax legislation in 2017 While that legislation discussed further below did not repeal the [A Review of the Affordable Care Act at 10 Years, Part 1 - Mintz](https://mintz.com/insights-center/viewpoints/2146/2020-04-07-review-affordable-care-act-10-years-part-1-individual)
+
+[^4]: Is the individual mandate severable from the ACA The challengers argued that even though there is no enforceable penalty now the text of the ACA indicates that the individual mandate is inextricably tied to its functioning Some of the justices appeared to agree with this assessment noting that in the 2012 case the ACA s defenders contended that the mandate was essential for ensuring successful operation of the ACA [While the Supreme Court Appears Likely to Uphold the Affordable](https://nashp.org/while-the-supreme-court-appears-likely-to-uphold-the-affordable-care-act-states-still-face-uncertainty)
+
+[^5]: The state challengers main argument is that because the Supreme Court s 2012 decision centered on whether the mandate was a valid exercise of Congress taxing power with the mandate no longer generating federal revenue it is now unconstitutional Also the challengers argued that the specific language used in the text of the mandate obligates individuals to purchase coverage despite the fact there is no longer a penalty for not buying health insurance [While the Supreme Court Appears Likely to Uphold the Affordable](https://nashp.org/while-the-supreme-court-appears-likely-to-uphold-the-affordable-care-act-states-still-face-uncertainty)
+
+[^6]: Sebelius upheld the constitutionality of the ACA based on Congress taxing power now that there is no revenue associated with the mandate penalty it can no longer be considered a tax and consequently the individual mandate is unconstitutional The plaintiffs also argue that because the individual mandate is so crucial to the ACA the entire law should be ruled unconstitutional [While the Supreme Court Appears Likely to Uphold the Affordable](https://nashp.org/while-the-supreme-court-appears-likely-to-uphold-the-affordable-care-act-states-still-face-uncertainty)
+
+[^7]: At issue here is the assertion that the Commerce Clause can only reach individuals and entities engaged in an activity and because the plaintiffs maintain [Obamacare Is Unconstitutional - Cato Institute](https://cato.org/policy-report/march/april-2011/obamacare-unconstitutional)

AI_core/tools/__init__.py

@@ -0,0 +1,37 @@
+"""
+Legal Assistant tools initialization.
+"""
+from langchain.tools import Tool
+
+from AI_core.tools.summarization_tool import SummarizationTool
+from AI_core.tools.report_generation_tool import ReportGenerationTool
+from AI_core.tools.evidence_analysis_tool import EvidenceAnalysisTool
+from AI_core.tools.legal_qa_tool import LegalQATool
+from AI_core.tools.element_extraction_tool import ElementExtractionTool
+
+# Create tool instances
+summarization_tool = SummarizationTool()
+report_generation_tool = ReportGenerationTool()
+evidence_analysis_tool = EvidenceAnalysisTool()
+legal_qa_tool = LegalQATool()
+element_extraction_tool = ElementExtractionTool()
+
+# Create tools list for the agent
+tools = [
+    Tool.from_function(
+        func=summarization_tool._run,
+        name="document_summarization_tool",
+        description="Summarizes legal documents. Input should be a file path to a PDF or text document."
+    ),
+    report_generation_tool,
+    evidence_analysis_tool,
+    Tool.from_function(
+        func=legal_qa_tool._run,
+        name="legal_qa_tool",
+        description="Answers legal questions. Input should be a clear legal question."
+    ),
+    element_extraction_tool
+]
+
+__all__ = ['tools', 'summarization_tool', 'report_generation_tool', 
+           'evidence_analysis_tool', 'legal_qa_tool', 'element_extraction_tool']

AI_core/tools/element_extraction_tool.py

@@ -0,0 +1,62 @@
+"""
+Tool for extracting specific legal elements from texts.
+"""
+from langchain.tools import BaseTool
+from langchain.prompts import ChatPromptTemplate
+from langchain.schema import SystemMessage, HumanMessage
+
+from AI_core.config import AGENT_LLM
+
+class ElementExtractionTool(BaseTool):
+    """Tool to extract specific legal elements from legal texts."""
+    name: str = "legal_element_extraction_tool"
+    description: str = "Extracts specific legal elements from legal texts such as contracts, judgments, or legal briefs."
+    
+    def _run(self, query: str) -> str:
+        """
+        Extract specific legal elements from texts.
+        
+        Args:
+            query: Legal text to extract elements from
+            
+        Returns:
+            str: Extracted legal elements
+        """
+        # Define extraction schema
+        schema = {
+            "title": "Extractor",
+            "description": "Extract relevant legal elements.",
+            "type": "object",            
+            "properties": {
+                "parties": {"type": "array", "items": {"type": "string"}, "description": "The parties involved in the legal document"},
+                "dates": {"type": "array", "items": {"type": "string"}, "description": "Important dates mentioned in the document"},
+                "obligations": {"type": "array", "items": {"type": "string"}, "description": "Legal obligations specified in the document"},
+                "jurisdiction": {"type": "string", "description": "The legal jurisdiction that applies"},
+                "legal_citations": {"type": "array", "items": {"type": "string"}, "description": "Citations of laws, regulations, or precedents"},
+                "monetary_values": {"type": "array", "items": {"type": "string"}, "description": "Monetary amounts mentioned in the document"}
+            },
+            "required": ["parties"]
+        }
+        
+        # Create extraction chain
+        extraction_prompt = ChatPromptTemplate.from_messages([
+            SystemMessage(content="You are a legal element extraction expert. Extract the requested information from the provided legal text."),
+            HumanMessage(content="Extract the following information from this legal text: {query}")
+        ])
+        extraction_chain = extraction_prompt | AGENT_LLM.with_structured_output(schema=schema)
+        
+        # Run extraction
+        try:
+            result = extraction_chain.invoke({"query": query})
+            # Format result for better readability
+            formatted_result = "Extracted Legal Elements:\n\n"
+            for key, value in result.items():
+                if isinstance(value, list):
+                    formatted_result += f"{key.capitalize()}:\n"
+                    for item in value:
+                        formatted_result += f"- {item}\n"
+                else:
+                    formatted_result += f"{key.capitalize()}: {value}\n"
+            return formatted_result
+        except Exception as e:
+            return f"Error extracting elements: {str(e)}"

AI_core/tools/evidence_analysis_tool.py

@@ -0,0 +1,53 @@
+"""
+Tool for analyzing legal evidence using DEEPresearch.
+"""
+import requests
+import json
+from langchain.tools import BaseTool
+
+from AI_core.config import DEEPSEARCH_API_URL
+
+class EvidenceAnalysisTool(BaseTool):
+    """Tool to analyze legal evidence using DEEPresearch."""
+    name: str = "evidence_analysis_tool"
+    description: str = "Analyzes legal evidence using DEEPresearch and builds relationships between entities. Input should be a legal query about evidence or case analysis."
+    
+    def _run(self, query: str) -> str:
+        """
+        Analyze legal evidence using DEEPresearch.
+        
+        Args:
+            query: Legal query about evidence or case analysis
+            
+        Returns:
+            str: Analysis results from DEEPresearch
+        """
+        headers = {
+            'Content-Type': 'application/json'
+        }
+        
+        data = {
+            "model": "jina-deepsearch-v1",
+            "messages": [
+                {
+                    "role": "system",
+                    "content": "You are a legal evidence analyst. Your task is to analyze legal evidence, extract key entities, and establish relationships between them."
+                },
+                {
+                    "role": "user",
+                    "content": query
+                }
+            ],
+            "stream": False,
+            "reasoning_effort": "low",
+            "max_attempts": 2,
+            "no_direct_answer": False
+        }
+
+        try:
+            # In production, use actual API call
+            response = requests.post(DEEPSEARCH_API_URL, headers=headers, json=data)
+            result = response.json()['choices'][0]['message']['content']
+            return result
+        except Exception as e:
+            return f"Error analyzing evidence with DEEPresearch: {str(e)}"

AI_core/tools/legal_qa_tool.py

@@ -0,0 +1,68 @@
+"""
+Tool for answering legal questions using a knowledge base.
+"""
+from langchain.tools import BaseTool
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+from langchain.memory import ConversationBufferMemory
+
+from AI_core.config import LLM
+
+class LegalQATool(BaseTool):
+    """Tool to answer legal questions using a knowledge base."""
+    name: str = "legal_qa_tool"
+    description: str = "Answers legal questions using a knowledge base of laws and regulations."
+    memory: ConversationBufferMemory = None
+    
+    def __init__(self):
+        """Initialize the legal QA tool with conversation memory."""
+        super().__init__()
+        # Initialize memory in the constructor
+        self.memory = ConversationBufferMemory(
+            memory_key="chat_history",
+            return_messages=True
+        )
+    
+    def _run(self, query: str) -> str:
+        """
+        Answer legal questions using a knowledge base.
+        
+        Args:
+            query: Legal question to answer
+            
+        Returns:
+            str: Answer to the legal question
+        """
+        # In production environment:
+        # 1. Load vector store with legal documents
+        # 2. Create retriever from vector store
+        # 3. Create ConversationalRetrievalChain
+        
+        template = """
+        You are a legal assistant specializing in answering legal questions.
+        
+        Use your knowledge of laws and regulations to provide an accurate and helpful answer to the question.
+        
+        Question: {question}
+        
+        Provide a clear, concise answer citing relevant laws or precedents when appropriate.
+        Include a disclaimer that your answer is not legal advice.
+        """
+        
+        prompt = PromptTemplate(
+            template=template,
+            input_variables=["question"]
+        )
+        
+        qa_chain = LLMChain(
+            llm=LLM,
+            prompt=prompt
+        )
+        
+        response = qa_chain.run(question=query)
+        
+        # Update conversation memory
+        self.memory.chat_memory.add_user_message(query)
+        self.memory.chat_memory.add_ai_message(response)
+        
+        return response

AI_core/tools/report_generation_tool.py

@@ -0,0 +1,74 @@
+"""
+Tool for generating legal case reports.
+"""
+from typing import Type
+from langchain.tools import BaseTool
+from langchain.prompts import PromptTemplate
+
+from AI_core.config import LLM
+from AI_core.models.input_schemas import ReportGenerationInput
+
+class ReportGenerationTool(BaseTool):
+    """Tool to generate comprehensive legal case reports."""
+    name: str = "case_report_generation_tool"
+    description: str = "Generates comprehensive legal case reports based on provided case information, input to this tool must be a SINGLE JSON STRING"
+    args_schema: Type[ReportGenerationInput] = ReportGenerationInput
+    
+    def _run(self, case_name: str, case_facts: str, legal_issues: str, applicable_laws: str) -> str:
+        """
+        Generate a comprehensive legal case report.
+        
+        Args:
+            case_name: Name of the legal case
+            case_facts: Key facts of the case
+            legal_issues: Legal issues identified in the case
+            applicable_laws: Laws and regulations applicable to this case
+            
+        Returns:
+            str: Formatted legal case report
+        """
+        report_template = """
+        You are a legal professional drafting a formal case report.
+        
+        Create a comprehensive legal case report with the following structure:
+        
+        # CASE REPORT: {case_name}
+        
+        ## EXECUTIVE SUMMARY
+        Provide a brief overview of the case, its significance, and the outcome (if known).
+        
+        ## CASE FACTS
+        {case_facts}
+        
+        ## LEGAL ISSUES
+        {legal_issues}
+        
+        ## APPLICABLE LAWS AND REGULATIONS
+        {applicable_laws}
+        
+        ## LEGAL ANALYSIS
+        Analyze how the applicable laws relate to the facts and issues of this case. Include relevant legal precedents if appropriate.
+        
+        ## POTENTIAL ARGUMENTS
+        Outline possible arguments for both sides of the case.
+        
+        ## CONCLUSION
+        Provide a concluding assessment of the case's legal position, potential outcomes, and recommendations.
+        """
+        
+        report_prompt = PromptTemplate(
+            template=report_template,
+            input_variables=["case_name", "case_facts", "legal_issues", "applicable_laws"]
+        )
+
+        report_chain = report_prompt | LLM 
+        
+        output = report_chain.invoke(
+            {
+                "case_name": case_name,
+                "case_facts": case_facts,
+                "legal_issues": legal_issues,
+                "applicable_laws": applicable_laws
+            }
+        )
+        return output.content

AI_core/tools/summarization_tool.py

@@ -0,0 +1,65 @@
+"""
+Tool for summarizing legal documents.
+"""
+from langchain.tools import BaseTool
+from langchain.chains import LLMChain, MapReduceDocumentsChain
+from langchain.prompts import PromptTemplate
+from langchain.document_loaders import PyPDFLoader
+
+from AI_core.config import LLM, TEXT_SPLITTER
+
+class SummarizationTool(BaseTool):
+    """Tool to summarize legal documents using a map-reduce approach."""
+    name: str = "document_summarization_tool"
+    description: str = "Summarizes legal documents. Input should be a file path to a PDF or text document."
+    
+    def _run(self, file_path: str) -> str:
+        """
+        Run the document summarization process.
+        
+        Args:
+            file_path: Path to the document to summarize
+            
+        Returns:
+            str: Summarized content
+        """
+        # Load document
+        if file_path.endswith('.pdf'):
+            loader = PyPDFLoader(file_path)
+            documents = loader.load()
+        else:
+            with open(file_path, 'r') as f:
+                text = f.read()
+            documents = [text]
+        
+        # Split documents
+        docs = TEXT_SPLITTER.split_documents(documents)
+        
+        # Map step - summarize each chunk
+        map_template = """
+        You are a legal expert summarizing complex legal documents.
+        Summarize the following text in a concise and accurate manner, preserving key legal points:
+        
+        {text}
+        """
+        map_prompt = PromptTemplate(template=map_template, input_variables=["text"])
+        map_chain = LLMChain(llm=LLM, prompt=map_prompt, output_key="summary")
+        
+        # Reduce step - combine summaries
+        reduce_template = """
+        You are a legal expert creating a comprehensive summary from multiple text segments.
+        Combine these summaries into a cohesive overview of the entire document, organized by key legal themes and points:
+        
+        {summaries}
+        """
+        reduce_prompt = PromptTemplate(template=reduce_template, input_variables=["summaries"])
+        reduce_chain = LLMChain(llm=LLM, prompt=reduce_prompt)
+        
+        # Create MapReduce chain
+        map_reduce_chain = MapReduceDocumentsChain(
+            llm_chain=map_chain,
+            reduce_documents_chain=reduce_chain,
+            document_variable_name="text",
+        )
+        
+        return map_reduce_chain.run(docs)

backend/__init__.py

@@ -0,0 +1,3 @@
+"""
+Backend package initialization.
+"""

backend/config.py

@@ -0,0 +1,28 @@
+"""
+Backend configuration settings.
+"""
+import os
+
+# Server configuration
+HOST = os.getenv("HOST", "0.0.0.0")
+PORT = int(os.getenv("PORT", 8000))
+DEBUG = os.getenv("DEBUG", "False").lower() == "true"
+
+# API configuration
+API_VERSION = "v1"
+API_PREFIX = f"/api/{API_VERSION}"
+
+# Logging configuration
+LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
+
+# CORS settings
+ALLOWED_ORIGINS = [
+    "http://localhost:3000",
+    "http://127.0.0.1:3000",
+    "http://localhost:8080",
+    "http://127.0.0.1:8080",
+    "*"  # For development - remove in production
+]
+
+# Rate limiting
+RATE_LIMIT = "100/minute"

backend/endpoint/__init__.py

@@ -0,0 +1,3 @@
+"""
+Endpoint package initialization.
+"""

backend/endpoint/api.py

@@ -0,0 +1,125 @@
+"""
+API endpoints for the Legal Assistant service.
+"""
+import sys
+import time
+import uuid
+import logging
+from fastapi import FastAPI, HTTPException, Depends, Request, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import asyncio
+from typing import Dict, Optional
+
+# Add AI_core to path so we can import it
+import os
+import sys
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../..')))
+
+# Import the process_legal_request function from AI_core
+from AI_core.main import process_legal_request
+
+# Import models and config
+from .models import QueryRequest, QueryResponse, HealthResponse
+from ..config import API_PREFIX, API_VERSION, ALLOWED_ORIGINS
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Create FastAPI app
+app = FastAPI(
+    title="Legal Assistant API",
+    description="API for interacting with the Legal AI Assistant",
+    version=API_VERSION,
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=ALLOWED_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Session storage to maintain context
+# In production, use a persistent storage solution
+sessions: Dict[str, Dict] = {}
+
+@app.get(f"{API_PREFIX}/health", response_model=HealthResponse)
+async def health_check():
+    """
+    Health check endpoint to verify the API is running correctly.
+    """
+    return HealthResponse(
+        status="ok",
+        version=API_VERSION,
+        components={
+            "api": "healthy",
+            "agent": "healthy",
+            "tools": "healthy"
+        }
+    )
+
+@app.post(f"{API_PREFIX}/query", response_model=QueryResponse)
+async def query(request: QueryRequest):
+    """
+    Process a legal query and return a response from the Legal AI Assistant.
+    """
+    # Generate session ID if not provided
+    session_id = request.session_id or str(uuid.uuid4())
+    
+    # Log request
+    logger.info(f"Processing query for session {session_id}: {request.query[:50]}...")
+    
+    # Measure processing time
+    start_time = time.time()
+    
+    try:
+        # Process the query using the AI core
+        response = await process_legal_request(request.query)
+        
+        # Calculate processing time
+        processing_time = time.time() - start_time
+        
+        # Return the response
+        return QueryResponse(
+            response=response,
+            session_id=session_id,
+            metadata={"tools_used": []},  # In a production version, track tools used
+            processing_time=processing_time
+        )
+    
+    except Exception as e:
+        logger.error(f"Error processing query: {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error processing your request: {str(e)}"
+        )
+
+@app.get(f"{API_PREFIX}/sessions/{{session_id}}")
+async def get_session(session_id: str):
+    """
+    Get information about a specific session.
+    """
+    if session_id not in sessions:
+        raise HTTPException(
+            status_code=404,
+            detail=f"Session {session_id} not found"
+        )
+    
+    return sessions[session_id]
+
+@app.delete(f"{API_PREFIX}/sessions/{{session_id}}")
+async def delete_session(session_id: str):
+    """
+    Delete a specific session.
+    """
+    if session_id in sessions:
+        del sessions[session_id]
+    
+    return {"status": "success", "message": f"Session {session_id} deleted"}

backend/endpoint/models.py

@@ -0,0 +1,27 @@
+"""
+Pydantic models for the API endpoints.
+"""
+from pydantic import BaseModel, Field
+from typing import Optional, List, Dict, Any
+
+
+class QueryRequest(BaseModel):
+    """Model for legal query requests."""
+    query: str = Field(..., description="The legal query or request from the user")
+    session_id: Optional[str] = Field(None, description="Session identifier for tracking conversation context")
+    options: Optional[Dict[str, Any]] = Field(None, description="Additional options for query processing")
+
+
+class QueryResponse(BaseModel):
+    """Model for legal query responses."""
+    response: str = Field(..., description="The response from the legal assistant")
+    session_id: Optional[str] = Field(None, description="Session identifier that tracks the conversation")
+    metadata: Optional[Dict[str, Any]] = Field(None, description="Additional metadata about the response")
+    processing_time: Optional[float] = Field(None, description="Time taken to process the query in seconds")
+
+
+class HealthResponse(BaseModel):
+    """Model for health check responses."""
+    status: str = Field(..., description="Health status of the API")
+    version: str = Field(..., description="API version")
+    components: Dict[str, str] = Field(..., description="Status of individual components")

backend/endpoint/server.py

@@ -0,0 +1,38 @@
+"""
+Server script to run the FastAPI application for the Legal Assistant API.
+"""
+import uvicorn
+import logging
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from .env file if it exists
+load_dotenv()
+
+# Import configuration
+from ..config import HOST, PORT, DEBUG
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO if not DEBUG else logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+def run_server():
+    """
+    Run the FastAPI server with uvicorn.
+    """
+    logger.info(f"Starting Legal Assistant API server at http://{HOST}:{PORT}")
+    logger.info(f"Debug mode: {DEBUG}")
+    
+    uvicorn.run(
+        "backend.endpoint.api:app",
+        host=HOST,
+        port=PORT,
+        reload=DEBUG,
+        log_level="info" if not DEBUG else "debug"
+    )
+
+if __name__ == "__main__":
+    run_server()

backend/requirement.txt

@@ -0,0 +1,6 @@
+fastapi>=0.101.0
+uvicorn>=0.23.0
+pydantic>=2.0.0
+python-dotenv>=1.0.0
+httpx>=0.24.1
+python-multipart>=0.0.6

run_server.py

@@ -0,0 +1,7 @@
+"""
+Main entry point to start the Legal Assistant API server.
+"""
+from backend.endpoint.server import run_server
+
+if __name__ == "__main__":
+    run_server()