Upload 12 files

__init__.py

@@ -0,0 +1,2 @@
+def hello() -> str:
+    return "Hello from lawgenie!"

app (5).py

@@ -0,0 +1,319 @@
+import json
+import os
+import re
+
+import regex
+import requests
+from dotenv import load_dotenv
+from flask import Flask, jsonify, request
+from together import Together
+from werkzeug.utils import secure_filename
+
+from lawgenie.crew import get_agent_output
+
+app = Flask(__name__)
+
+UPLOAD_FOLDER = "uploads"
+ALLOWED_EXTENSIONS = {"pdf", "docx"}
+
+app.config["UPLOAD_FOLDER"] = UPLOAD_FOLDER
+
+load_dotenv()
+
+TOGETHER_API_KEY = os.environ.get("TOGETHER_API_KEY")
+print("TOGETHER_API_KEY: ", TOGETHER_API_KEY)
+client = Together(api_key=TOGETHER_API_KEY)
+
+
+def allowed_file(filename):
+    return "." in filename and filename.rsplit(".", 1)[1].lower() in ALLOWED_EXTENSIONS
+
+
+def inspect_and_serialize(obj):
+    """
+    Inspect the object and return a JSON-serializable version of it.
+    """
+    if isinstance(obj, (str, int, float, bool, type(None))):
+        return obj
+    elif isinstance(obj, list):
+        return [inspect_and_serialize(item) for item in obj]
+    elif isinstance(obj, dict):
+        return {key: inspect_and_serialize(value) for key, value in obj.items()}
+    elif hasattr(obj, "__dict__"):
+        return inspect_and_serialize(obj.__dict__)
+    else:
+        return str(obj)
+
+
+def debug_crew_output(crew_output):
+    print("Type of crew_output:", type(crew_output))
+    print("Content of crew_output:")
+    print(json.dumps(inspect_and_serialize(crew_output), indent=2))
+
+
+def parse_combined_output(combined_output):
+    sections = {}
+    current_section = None
+    current_summary = ""
+    current_full_text = ""
+    lines = combined_output.splitlines()
+
+    for line in lines:
+        line = line.strip()
+        if line.startswith("Section Name:"):
+            if current_section:
+                sections[current_section] = {
+                    "summary": current_summary.strip(),
+                    "full_text": current_full_text.strip(),
+                }
+
+            current_section = line[len("Section Name:") :].strip()
+            current_summary = ""
+            current_full_text = ""
+        elif line.startswith("Summary:"):
+            current_summary = line[len("Summary:") :].strip()
+        elif line.startswith("Full Text:"):
+            current_full_text = line[len("Full Text:") :].strip()
+        elif current_section:
+            current_full_text += line + " "
+
+    if current_section:
+        sections[current_section] = {
+            "summary": current_summary.strip(),
+            "full_text": current_full_text.strip(),
+        }
+
+    return sections
+
+
+def extract_json(text):
+    match = regex.search(r"\{(?:[^{}]|(?R))*\}", text, regex.DOTALL)
+    if match:
+        return match.group(0)
+    else:
+        raise ValueError("No JSON object found in the response.")
+
+
+def call_llama_via_together_ai(prompt):
+    response = client.chat.completions.create(
+        model="meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+        messages=[{"role": "user", "content": prompt}],
+        max_tokens=2048,
+        temperature=0.0,
+        top_p=0.7,
+        top_k=50,
+        repetition_penalty=1,
+        stop=["<|eot_id|>", "<|eom_id|>"],
+        stream=False,
+    )
+    return response.choices[0].message.content
+
+
+def segment_contract(contract_text):
+    print("In segment")
+    print(f"Contract text length: {len(contract_text)}")
+
+    chunk_size = 16000
+    chunks = [
+        contract_text[i : i + chunk_size]
+        for i in range(0, len(contract_text), chunk_size)
+    ]
+    print(f"Number of chunks: {len(chunks)}")
+    combined_output = ""
+
+    for idx, chunk in enumerate(chunks):
+        prompt = f"""
+        Analyze the following part {idx+1}/{len(chunks)} of a Non-Disclosure Agreement (NDA) and segment it into key sections.
+
+        Focus on identifying these common NDA sections:
+
+        1. Parties
+        2. Definition of Confidential Information
+        3. Obligations of Receiving Party
+        4. Exclusions from Confidential Information
+        5. Term and Termination
+        6. Return of Confidential Information
+        7. Remedies
+
+        For each identified section, provide:
+
+        - Section Name: [Name of the section]
+        - Summary: [A brief summary of what the section covers (1-2 sentences)]
+        - Full Text: [The full text of the section. Do not skip any text within each section.]
+
+        If a section is not present in this part, ignore it.
+
+        If you find additional important sections not listed above, include them as well.
+
+        Output Format:
+
+        For each section, output in the following format:
+
+        Section Name: [Name] Summary: [Summary] Full Text: [Full text]
+
+        Do not include any additional text outside this format.
+
+        NDA text part {idx+1}/{len(chunks)}:
+        {chunk}
+        """
+        try:
+            print(f"Processing chunk {idx+1}/{len(chunks)}")
+            response_content = call_llama_via_together_ai(prompt)
+            print(f"Received response for chunk {idx+1}")
+            combined_output += response_content + "\n"
+        except Exception as e:
+            print(f"An error occurred while processing chunk {idx+1}: {e}")
+            continue
+
+    print("Segmentation complete.")
+    return combined_output
+
+
+def parse_contract(file_path):
+    api_key = os.getenv("UPSTAGE_API_KEY")
+    if not api_key:
+        raise Exception("API key is missing")
+    print(f"API Key: {api_key}")
+
+    url = "https://api.upstage.ai/v1/document-ai/document-parse"
+    headers = {"Authorization": f"Bearer {api_key}"}
+
+    try:
+        with open(file_path, "rb") as file:
+            files = {"document": file}
+            data = {"ocr": "auto", "coordinates": "false", "output_formats": "['text']"}
+            print("Sending request to Document Parse API...")
+            response = requests.post(url, headers=headers, files=files, data=data)
+
+            if response.status_code == 200:
+                result = response.json()
+                print(f"API Response: {json.dumps(result, indent=2)}")
+
+                contract_text = ""
+                if "content" in result and "text" in result["content"]:
+                    contract_text = result["content"]["text"]
+                else:
+                    print("Warning: 'content' or 'text' not found in API response")
+                    for page in result.get("pages", []):
+                        for element in page.get("elements", []):
+                            if element.get("category") == "text":
+                                contract_text += element.get("text", "") + "\n"
+
+                print(f"Extracted text length: {len(contract_text)}")
+                print(f"First 500 characters of extracted text: {contract_text[:500]}")
+
+                if len(contract_text) == 0:
+                    print("Warning: No text extracted from the document")
+                    print("API Response structure:")
+                    print(json.dumps(result, indent=2))
+
+                return contract_text
+            else:
+                raise Exception(
+                    f"Error in Document Parse API: {response.status_code}, {response.text}"
+                )
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        raise
+
+
+def segment_clauses(text):
+    return [
+        clause.strip() for clause in re.split(r"\n\n|\r\n\r\n", text) if clause.strip()
+    ]
+
+
+def generate_recommendation(clause, analysis):
+    recommendations = []
+    if "payment" in analysis:
+        recommendations.append(
+            "Ensure payment terms are clearly defined and favorable."
+        )
+    if "deadline" in analysis:
+        recommendations.append(
+            "Review deadlines to ensure they are realistic and include buffer time."
+        )
+    if "confidentiality" in analysis:
+        recommendations.append(
+            "Verify that confidentiality clauses protect your interests adequately."
+        )
+    if "termination" in analysis:
+        recommendations.append(
+            "Check termination conditions and ensure they are fair to both parties."
+        )
+
+    return (
+        recommendations
+        if recommendations
+        else ["No specific recommendations. The clause appears standard."]
+    )
+
+
+@app.route("/analyze", methods=["POST"])
+def analyze_contract():
+    data = request.json
+    contract_text = data.get("text", "")
+    clauses = segment_clauses(contract_text)
+
+    analysis = [
+        {"clause": clause, "analysis": analyze_clause(clause)}  # noqa: F821
+        for clause in clauses
+    ]
+    return jsonify({"analysis": analysis})
+
+
+@app.route("/upload", methods=["POST"])
+def upload_file():
+    if "file" not in request.files:
+        return jsonify({"error": "No file part"}), 400
+    file = request.files["file"]
+    if file.filename == "":
+        return jsonify({"error": "No selected file"}), 400
+    if file and allowed_file(file.filename):
+        filename = secure_filename(file.filename)
+        file_path = os.path.join(app.config["UPLOAD_FOLDER"], filename)
+        file.save(file_path)
+        print(f"File saved: {file_path}")
+        print(f"File size: {os.path.getsize(file_path)} bytes")
+        try:
+            print("Parsing contract...")
+            contract_text = parse_contract(file_path)
+            print(f"Parsed contract text length: {len(contract_text)}")
+            print("Contract parsed. Starting segmentation...")
+            combined_output = segment_contract(contract_text)
+            print("Parsing combined output...")
+            segmented_contract = parse_combined_output(combined_output)
+            print("Segmentation complete.")
+
+            crew_output = get_agent_output(segmented_contract)
+            debug_crew_output(crew_output)
+
+            response_data = {
+                "message": "File uploaded and processed successfully",
+                "segmented_contract": segmented_contract,
+                "crew_analysis": inspect_and_serialize(crew_output),
+            }
+            print("Response Data:", response_data)
+
+            return jsonify(response_data)
+        except Exception as e:
+            print(f"An error occurred: {str(e)}")
+            import traceback
+
+            traceback.print_exc()
+            return jsonify({"error": str(e)}), 500
+    return jsonify({"error": "File type not allowed"}), 400
+
+
+@app.route("/recommend", methods=["POST"])
+def recommend():
+    data = request.json
+    clause = data.get("clause", "")
+    analysis = data.get("analysis", [])
+    recommendations = generate_recommendation(clause, " ".join(analysis))
+    return jsonify({"recommendations": recommendations})
+
+
+if __name__ == "__main__":
+    os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+    app.run(host="0.0.0.0", debug=True, port=5002)

clause_agents.py

@@ -0,0 +1,89 @@
+import os
+
+from crewai import Agent
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+
+from lawgenie.tools import rag_query_tools, rag_tools
+
+load_dotenv()
+
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
+OPENAI_API_BASE = os.environ.get("OPENAI_API_BASE")
+OPENAI_MODEL_NAME = os.environ.get("OPENAI_MODEL_NAME")
+llm = ChatOpenAI(
+    openai_api_key=OPENAI_API_KEY,
+    # openai_api_base=OPENAI_API_BASE,
+    model_name="gpt-4o-mini",
+)
+
+
+corporate_lawyer_agent = Agent(
+    role="Corporate Lawyer",
+    goal="Use the documents you're given and the tools you have to build a knowledge base of NDAs that you can refer later. First, check if the documents have already been added.",
+    backstory="""You are a corporate lawyer who has vast knowledge of NDAs, different sections within them, and how they are supposed to work.
+    You also have the ability to call the RAG tool to ingest new documents that using the paths of files given to you and building a knowledge base of NDAs.""",
+    tools=rag_tools,
+    verbose=True,
+    llm=llm,
+)
+
+### Clause agents and tasks here - try to check if one agent can be used for multiple clauses, since handoff between agents takes time
+parties_corporate_lawyer = Agent(
+    role="Parties Corporate Lawyer",
+    goal="To compare the current NDA parties clause to the ones in our RAG database and identify how good it is.",
+    backstory="""You are a corporate lawyer who specialises in identifying who the parties in a certain NDA are.
+    There's no one who does it as well as you do. Things that others miss, you don't.""",
+    tools=rag_query_tools,
+    verbose=True,
+    llm=llm,
+)
+
+# obligations of receiving party
+obligation_information_lawyer = Agent(
+    role="Obligations of Receiving Party Lawyer",
+    goal="To compare the current NDA obligations of receiving party clause to the ones in our RAG database and identify how good it is.",
+    backstory="""You are an obligations of receiving party lawyer who is an expert in identifying what the obligations of receiving party is in a certain NDA.
+    You have never failed to identify obligations of receiving party in an NDA. You are a lawyer with many years of experience and know how to identify obligations of receiving party.
+    """,
+    tools=rag_query_tools,
+    verbose=True,
+    llm=llm,
+)
+
+
+# terms and termination
+terms_and_termination_lawyer = Agent(
+    role="Terms and Termination Lawyer",
+    goal="To compare the current NDA terms and termination clause to the ones in our RAG database and identify how good it is.",
+    backstory="""You are a terms and termination lawyer who is an expert in identifying what the terms and termination is in a certain NDA.
+    Terms and terminatioin are in your DNA. When given an NDA, you're eyes first go to terms and termination clause and you can identify fallacies well.
+    """,
+    tools=rag_query_tools,
+    verbose=True,
+    llm=llm,
+)
+
+# remedies
+remedies_lawyer = Agent(
+    role="Remedies Lawyer",
+    goal="To compare the current NDA remedies clause to the ones in our RAG database and identify how good it is.",
+    backstory="""You are a remedies lawyer who is an expert in identifying what the remedies is in a certain NDA.
+    You craft perfect remedies in an NDA in the case of breach or conflict. You are the go to person for remedies in an NDA.
+    """,
+    tools=rag_query_tools,
+    verbose=True,
+    llm=llm,
+)
+
+# additional important information
+additional_information_lawyer = Agent(
+    role="Additional Important Information Lawyer",
+    goal="To compare the current NDA additional important information clause to the ones in our RAG database and identify how good it is.",
+    backstory="""You are an additional important information lawyer who is an expert in identifying what the additional important information is in a certain NDA.
+    You identify up all the missing information in an NDA. You carefully craft perfect additional important information in an NDA.
+    """,
+    tools=rag_query_tools,
+    verbose=True,
+    llm=llm,
+)

clause_tasks.py

@@ -0,0 +1,106 @@
+from crewai import Task
+from dotenv import load_dotenv
+
+from lawgenie.clause_agents import (
+    additional_information_lawyer,
+    corporate_lawyer_agent,
+    obligation_information_lawyer,
+    parties_corporate_lawyer,
+    remedies_lawyer,
+    terms_and_termination_lawyer,
+)
+from lawgenie.models import AgentOutput
+
+load_dotenv()
+
+EXPECTED_TASK_OUTPUT = """
+A JSON that has two keys: an `analysis` of the current clause in laymen terms as a paragraph as well as a `recommendation` of how the current clause deviates from the benchmark clauses (in short, numbered points)."""
+
+
+def create_accumulating_task(original_task, key):
+    def accumulating_task(agent, context):
+        result = original_task.function(agent, context)
+        if "accumulated_results" not in context:
+            context["accumulated_results"] = {}
+        context["accumulated_results"][key] = result
+        return context["accumulated_results"]
+
+    return Task(
+        description=original_task.description,
+        agent=original_task.agent,
+        function=accumulating_task,
+        expected_output=original_task.expected_output,
+        output_pydantic=original_task.output_pydantic,
+        context=original_task.context,
+    )
+
+
+def get_tasks(input_document):
+    tasks = []
+
+    ingest_documents_task = Task(
+        description="""Ingest benchmark NDAs that will be used as a yardstick to compare NDAs we will judge later.
+        Check all the files with NDA in their title in the ndas folder inside the current directory and ingest all the documents using the RAG tool.
+        Don't bother with the files inside the uploads folder.
+        Only ingest files with docx, doc, and pdf extensions. You don't need to analyze these documents.
+        If you pass the path of the documents to the RAG tool, it should be able to parse the documents.""",
+        expected_output=EXPECTED_TASK_OUTPUT,
+        agent=corporate_lawyer_agent,
+    )
+    tasks.append(create_accumulating_task(ingest_documents_task, "ingest_documents"))
+
+    identify_parties = Task(
+        description=f"""Take the current parties clause, which is inside this: `{input_document}`, and compare it with similar clauses in our RAG database to check how good it is.
+    Your task is to identify the parties in our NDA, and see if the current NDA clause abides by all the best practices of similar clauses.
+    There is a party that offers services, and there's a party that consumes services. This should be well defined within the clauses.""",
+        expected_output=EXPECTED_TASK_OUTPUT,
+        agent=parties_corporate_lawyer,
+        output_pydantic=AgentOutput,
+    )
+    tasks.append(create_accumulating_task(identify_parties, "identify_parties"))
+
+    identify_obligations_of_receiving_party = Task(
+        description=f"""Take the current obligations of receiving party clause, which is inside this: `{input_document}`, and compare it with similar clauses in our RAG database to check how good it is.
+        Your task is to identify the obligations of receiving party in our NDA, and see if the current NDA clause abides by all the best practices of similar clauses.""",
+        expected_output=EXPECTED_TASK_OUTPUT,
+        agent=obligation_information_lawyer,
+        output_pydantic=AgentOutput,
+    )
+    tasks.append(
+        create_accumulating_task(identify_obligations_of_receiving_party, "obligations")
+    )
+
+    identify_terms_and_termination = Task(
+        description=f"""Take the current terms and termination clause, which is inside this: `{input_document}`, and compare it with similar clauses in our RAG database to check how good it is.
+        Your task is to identify the terms and termination in our NDA, and see if the current NDA clause abides by all the best practices of similar clauses.""",
+        expected_output=EXPECTED_TASK_OUTPUT,
+        agent=terms_and_termination_lawyer,
+        output_pydantic=AgentOutput,
+    )
+    tasks.append(
+        create_accumulating_task(
+            identify_terms_and_termination, "terms_and_termination"
+        )
+    )
+
+    identify_remedies = Task(
+        description=f"""Take the current remedies clause, which is inside this: `{input_document}`, and compare it with similar clauses in our RAG database to check how good it is.
+        Your task is to identify the remedies in our NDA, and see if the current NDA clause abides by all the best practices of similar clauses.""",
+        expected_output=EXPECTED_TASK_OUTPUT,
+        agent=remedies_lawyer,
+        output_pydantic=AgentOutput,
+    )
+    tasks.append(create_accumulating_task(identify_remedies, "remedies"))
+
+    identify_additional_information = Task(
+        description=f"""Take the current additional important information clause, which is inside this: `{input_document}`, and compare it with similar clauses in our RAG database to check how good it is.
+        Your task is to identify the additional important information in our NDA, and see if the current NDA clause abides by all the best practices of similar clauses.""",
+        expected_output=EXPECTED_TASK_OUTPUT,
+        agent=additional_information_lawyer,
+        output_pydantic=AgentOutput,
+    )
+    tasks.append(
+        create_accumulating_task(identify_additional_information, "additional_info")
+    )
+
+    return tasks

crew.py

@@ -0,0 +1,41 @@
+from crewai import Crew, Process
+from dotenv import load_dotenv
+
+from lawgenie.clause_agents import (
+    additional_information_lawyer,
+    corporate_lawyer_agent,
+    obligation_information_lawyer,
+    remedies_lawyer,
+    terms_and_termination_lawyer,
+)
+from lawgenie.clause_tasks import get_tasks
+
+load_dotenv()
+
+
+def get_crew(input_doc):
+    crew = Crew(
+        agents=[
+            corporate_lawyer_agent,
+            obligation_information_lawyer,
+            terms_and_termination_lawyer,
+            remedies_lawyer,
+            additional_information_lawyer,
+        ],
+        tasks=get_tasks(input_doc),
+        process=Process.sequential,
+        verbose=True,
+    )
+
+    return crew
+
+
+def get_agent_output(document_from_frontend):
+    crew = get_crew(document_from_frontend)
+    result = crew.kickoff()
+
+    if isinstance(result, dict) and "accumulated_results" in result:
+        return result["accumulated_results"]
+    else:
+        # Fallback in case the modification didn't work as expected
+        return {"final_recommendation": result}

env.example

@@ -0,0 +1,3 @@
+OPENAI_API_KEY='your-api-key'
+OPENAI_API_BASE='https://api.aimlapi.com/v1'
+OPENAI_MODEL_NAME='meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo'

gitignore.txt

@@ -0,0 +1,170 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+.vscode/
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+*.lock
+*.doc
+*.docx
+*.pdf
+
+db

models.py

@@ -0,0 +1,16 @@
+from typing import Dict
+
+from pydantic import BaseModel, Field
+
+
+class AgentOutput(BaseModel):
+    """Output of each clause agent"""
+
+    analysis: str = Field(description="An analysis of the section in laymen terms")
+    recommendation: str = Field(
+        description="How the current clause deviates from the benchmark documents"
+    )
+
+
+class FinalOutput(BaseModel):
+    data: Dict[str, AgentOutput]

pre-commit-config.yaml

@@ -0,0 +1,44 @@
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.6.0
+    hooks:
+    -   id: check-yaml
+    -   id: end-of-file-fixer
+    -   id: trailing-whitespace
+    -   id: check-added-large-files
+        args: ['--maxkb=100']
+    -   id: check-json
+    -   id: check-merge-conflict
+    -   id: check-toml
+    -   id: detect-private-key
+    -   id: forbid-submodules
+    -   id: name-tests-test
+    -   id: no-commit-to-branch
+    -   id: pretty-format-json
+-   repo: https://github.com/psf/black
+    rev: 24.8.0
+    hooks:
+    -   id: black
+- repo: https://github.com/astral-sh/ruff-pre-commit
+  # Ruff version.
+  rev: v0.6.4
+  hooks:
+    # Run the linter.
+    - id: ruff
+      types_or: [ python, pyi ]
+      args: [ --fix ]
+    # Run the formatter.
+    - id: ruff-format
+      types_or: [ python, pyi ]
+- repo: https://github.com/standard/standard
+  rev: v17.1.1
+  hooks:
+    - id: standard
+- repo: https://github.com/pycqa/isort
+  rev: 5.13.2
+  hooks:
+    - id: isort
+- repo: https://github.com/thlorenz/doctoc
+  rev: v2.2.0
+  hooks:
+    - id: doctoc

pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+name = "lawgenie"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "requests>=2.32.3",
+    "flask>=3.0.3",
+    "werkzeug>=3.0.4",
+    "pdfminer>=20191125",
+    "openai>=1.45.0",
+    "docx>=0.2.4",
+    "python-dotenv>=1.0.1",
+    "streamlit>=1.38.0",
+    "langgraph>=0.2.21",
+    "pre-commit>=3.8.0",
+    "crewai>=0.55.2",
+    "composio-crewai>=0.5.23",
+    "e2b>=0.17.2a37",
+    "pydantic>=2.9.1",
+    "langchain-openai>=0.1.25",
+    "together>=1.2.12",
+    "watchdog>=4.0.2",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.black]
+line-length = 88
+
+[tool.isort]
+profile = "black"

streamlit_app.py

@@ -0,0 +1,118 @@
+import requests
+import streamlit as st
+from together import Together
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Initialize Together AI client
+TOGETHER_API_KEY = os.getenv("TOGETHER_API_KEY")
+client = Together(api_key=TOGETHER_API_KEY)
+
+def call_llama_for_response(clauses_data):
+    prompt = "As an AI assistant specializing in contract analysis, draft a professional and courteous response to a contract drafter based on the following clause analyses and decisions:\n\n"
+    
+    for clause in clauses_data:
+        prompt += f"Clause: {clause['agent']}\n"
+        prompt += f"Analysis: {clause['analysis']}\n"
+        prompt += f"Recommendation: {clause['recommendation']}\n"
+        prompt += f"Decision: {clause['action']}\n"
+        if clause['action'] == 'Negotiate':
+            prompt += f"Negotiation points: {clause['negotiation_points']}\n"
+        prompt += "\n"
+    
+    prompt += "Draft a response that addresses each clause, explaining our position on acceptance, rejection, or negotiation. The tone should be professional, courteous, and constructive."
+
+    response = client.chat.completions.create(
+        model="meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+        messages=[{"role": "user", "content": prompt}],
+        max_tokens=2048,
+        temperature=0.3,
+        top_p=0.8,
+        top_k=50,
+        repetition_penalty=1,
+        stop=["<|eot_id|>", "<|eom_id|>"],
+        stream=False
+    )
+    return response.choices[0].message.content
+
+st.title("Contract Negotiation Assistant")
+
+# Use session state to store the uploaded file and analysis results
+if 'uploaded_file' not in st.session_state:
+    st.session_state.uploaded_file = None
+if 'analysis_results' not in st.session_state:
+    st.session_state.analysis_results = None
+
+# File uploader
+uploaded_file = st.file_uploader("Upload Contract", type=["pdf", "docx"])
+
+# If a new file is uploaded, update the session state and clear previous results
+if uploaded_file is not None and uploaded_file != st.session_state.uploaded_file:
+    st.session_state.uploaded_file = uploaded_file
+    st.session_state.analysis_results = None
+
+# If we have an uploaded file, process it
+if st.session_state.uploaded_file is not None:
+    # Only call the API if we don't have analysis results yet
+    if st.session_state.analysis_results is None:
+        files = {"file": st.session_state.uploaded_file}
+        response = requests.post("http://localhost:5002/upload", files=files)
+        if response.status_code == 200:
+            st.write("Contract uploaded successfully. Analyzing...")
+            st.session_state.analysis_results = response.json()
+        else:
+            st.error("Failed to analyze the contract. Please try again.")
+
+    # If we have analysis results, display them and allow user interaction
+    if st.session_state.analysis_results is not None:
+        data = st.session_state.analysis_results
+        segmented_contract = data.get("segmented_contract", {})
+        crew_analysis = data.get("crew_analysis", {})
+
+        # Extract the tasks_output from the nested structure
+        tasks_output = crew_analysis.get("final_recommendation", {}).get("tasks_output", [])
+
+        clauses_data = []
+        for task in tasks_output:
+            agent = task.get("agent", "")
+            if task.get("pydantic"):
+                clause_analysis = task["pydantic"].get("analysis", "")
+                recommendation = task["pydantic"].get("recommendation", "")
+                
+                st.subheader(f"Clause: {agent}")
+                st.write("Analysis:")
+                st.write(clause_analysis)
+                st.write("Recommendation:")
+                st.write(recommendation)
+
+                action = st.selectbox(
+                    f"Action for {agent}",
+                    ["Accept", "Negotiate", "Reject"],
+                    key=f"action_{agent}"
+                )
+                negotiation_points = ""
+                if action == "Negotiate":
+                    negotiation_points = st.text_area("Enter your negotiation points:", key=f"negotiate_{agent}")
+                
+                clauses_data.append({
+                    "agent": agent,
+                    "analysis": clause_analysis,
+                    "recommendation": recommendation,
+                    "action": action,
+                    "negotiation_points": negotiation_points
+                })
+                
+                st.markdown("---")  # Add a separator between clauses
+
+        # Finalize Contract button
+        if st.button("Finalize Contract"):
+            with st.spinner("Generating response..."):
+                response_to_drafter = call_llama_for_response(clauses_data)
+            st.subheader("Response to Contract Drafter:")
+            st.text_area("", response_to_drafter, height=400)
+            st.success("Contract negotiation completed. Response generated for review.")
+
+else:
+    st.write("Please upload a contract to begin the analysis.")

tools.py

@@ -0,0 +1,18 @@
+from composio_crewai import Action, App, ComposioToolSet
+from dotenv import load_dotenv
+
+load_dotenv()
+
+tool_set = ComposioToolSet()
+rag_tools = tool_set.get_tools(
+    apps=[App.RAGTOOL],
+    actions=[
+        Action.FILETOOL_LIST_FILES,
+        Action.FILETOOL_CHANGE_WORKING_DIRECTORY,
+        Action.FILETOOL_FIND_FILE,
+    ],
+)
+
+rag_query_tools = tool_set.get_tools(
+    apps=[App.RAGTOOL],
+)