replace project2

Dockerfile

@@ -1,73 +1,31 @@
-# FROM python:3.10
-# RUN useradd -m -u 1000 user
-# USER root
-# ENV HOME=/home/user \
-#     PATH=/home/user/.local/bin:$PATH
-# WORKDIR $HOME/app
-# COPY --chown=user:user . $HOME/app
-# # COPY --chown=user . $HOME/app
-# COPY requirements.txt .
-# # COPY ./requirements.txt ~/app/requirements.txt
 
-# RUN pip install --upgrade pip
-# RUN pip install --no-cache-dir -r requirements.txt
-# # RUN pip install -r requirements.
-# # Expose port
-# EXPOSE 7860
-# # RUN pip install pydantic==2.10.1 chainlit
-# # COPY . .
+# Get a distribution that has uv already installed
+FROM ghcr.io/astral-sh/uv:python3.13-bookworm-slim
 
-# # Ensure app and .local have proper permissions
-# # USER root
-# RUN chmod -R 755 /home/user/app
-# RUN chmod -R 755 /home/user/.local
-# RUN mkdir -p /home/user/app/.files && chown -R user:user /home/user/app/.files
-
-
-# USER user
-
-# CMD ["chainlit", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]
-
-# # CMD ["chainlit", "run", "app.py", "--port", "7860"]
-
-
-FROM python:3.10
-
-# Create user with specific UID
+# Add user - this is the user that will run the app
+# If you do not set user, the app will run as root (undesirable)
 RUN useradd -m -u 1000 user
+USER user
 
-# Set environment variables
+# Set the home directory and path
 ENV HOME=/home/user \
-    PATH=/home/user/.local/bin:$PATH
+    PATH=/home/user/.local/bin:$PATH        
 
-# Set working directory
-WORKDIR $HOME/app
-
-# Copy requirements and install dependencies as root
-COPY requirements.txt .
-RUN pip install --upgrade pip && \
-    pip install --no-cache-dir -r requirements.txt
+ENV UVICORN_WS_PROTOCOL=websockets
 
-# Copy application files
-COPY . .
 
-# Create necessary directories and set permissions
-RUN mkdir -p /home/user/app/.files && \
-    mkdir -p /home/user/.local && \
-    chown -R user:user /home/user
-
-RUN pip install pydantic==2.10.1 chainlit
+# Set the working directory
+WORKDIR $HOME/app
 
-COPY chainlit.md .
+# Copy the app to the container
+COPY --chown=user . $HOME/app
 
+# Install the dependencies
+# RUN uv sync --frozen
+RUN uv sync
 
-# Expose port
+# Expose the port
 EXPOSE 7860
 
-# Switch to non-root user
-USER user
-
-# Run the application
-CMD ["chainlit", "run", "app.py", "--host", "0.0.0.0", "--port", "7860", "--no-cache"]
-
-# CMD ["chainlit", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]
+# Run the app
+CMD ["uv", "run", "chainlit", "run", "app.py", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -1,304 +1,139 @@
 import os
-import getpass
-from operator import itemgetter
-from typing import List, Dict
-import json
-import requests
-
-
-
-#LangChain, LangGraph
-from langchain_openai import ChatOpenAI
-from langgraph.graph import START, StateGraph, END
-from typing_extensions import List, TypedDict
-from langchain_core.documents import Document
-from langchain_core.prompts import ChatPromptTemplate
-from langchain.schema.output_parser import StrOutputParser
-from langchain_core.tools import Tool, tool
-from langgraph.prebuilt import ToolNode
-from typing import TypedDict, Annotated
-from langgraph.graph.message import add_messages
-import operator
-from langchain_core.messages import BaseMessage, HumanMessage, AIMessage
-from langchain.vectorstores import Qdrant
-from langchain.embeddings import OpenAIEmbeddings
-from langchain.schema import Document
-from qdrant_client import QdrantClient
-from qdrant_client.http.models import Distance, VectorParams
-
+from typing import List
+from chainlit.types import AskFileResponse
+from aimakerspace.text_utils import CharacterTextSplitter, TextFileLoader, PDFLoader
+from aimakerspace.openai_utils.prompts import (
+    UserRolePrompt,
+    SystemRolePrompt,
+    AssistantRolePrompt,
+)
+from aimakerspace.openai_utils.embedding import EmbeddingModel
+from aimakerspace.vectordatabase import VectorDatabase
+from aimakerspace.openai_utils.chatmodel import ChatOpenAI
 import chainlit as cl
-import tempfile
-import shutil
 
+system_template = """\
+Use the following context to answer a users question. If you cannot find the answer in the context, say you don't know the answer."""
+system_role_prompt = SystemRolePrompt(system_template)
 
+user_prompt_template = """\
+Context:
+{context}
 
+Question:
+{question}
+"""
+user_role_prompt = UserRolePrompt(user_prompt_template)
 
-#helper imports
-from code_analysis import *
-from tools import search_pypi, write_to_docx
-from prompts import describe_imports, main_prompt, documenter_prompt
-from states import AgentState
+class RetrievalAugmentedQAPipeline:
+    def __init__(self, llm: ChatOpenAI(), vector_db_retriever: VectorDatabase) -> None:
+        self.llm = llm
+        self.vector_db_retriever = vector_db_retriever
 
-os.environ["CHAINLIT_DISABLE_WEBSOCKETS"] = "true"
+    async def arun_pipeline(self, user_query: str):
+        context_list = self.vector_db_retriever.search_by_text(user_query, k=4)
 
+        context_prompt = ""
+        for context in context_list:
+            context_prompt += context[0] + "\n"
 
-# Global variables to store processed data
-processed_file_path = None
-document_file_path = None
-vectorstore = None
-main_chain = None
-qdrant_client = None
+        formatted_system_prompt = system_role_prompt.create_message()
 
-@cl.on_chat_start
-async def on_chat_start():
-    await cl.Message(content="Welcome to the Python Code Documentation Assistant! Please upload a Python file to get started.").send()
+        formatted_user_prompt = user_role_prompt.create_message(question=user_query, context=context_prompt)
 
-@cl.on_message
-async def on_message(message: cl.Message):
-    global processed_file_path, document_file_path, vectorstore, main_chain, qdrant_client
-    
-    if message.elements and any(el.type == "file" for el in message.elements):
-        file_elements = [el for el in message.elements if el.type == "file"]
-        file_element = file_elements[0]
-        is_python_file = (
-            file_element.mime.startswith("text/x-python") or 
-            file_element.name.endswith(".py") or
-            file_element.mime == "text/plain"  # Some systems identify .py as text/plain
-        )
-        if is_python_file:
-            # Send processing message
-            msg = cl.Message(content="Processing your Python file...")
-            await msg.send()
+        async def generate_response():
+            async for chunk in self.llm.astream([formatted_system_prompt, formatted_user_prompt]):
+                yield chunk
 
-            print(f'file element \n {file_element} \n')
+        return {"response": generate_response(), "context": context_list}
 
-            # Save uploaded file to a temporary location
-            temp_dir = tempfile.mkdtemp()
-            file_path = os.path.join(temp_dir, file_element.name)
+text_splitter = CharacterTextSplitter()
 
-            with open(file_element.path, "rb") as source_file:
-                file_content_bytes = source_file.read()
-                with open(file_path, "wb") as destination_file:
-                    destination_file.write(file_content_bytes)
-                
-            processed_file_path = file_path
 
+def process_file(file: AskFileResponse):
+    import tempfile
+    import shutil
+    
+    print(f"Processing file: {file.name}")
+    
+    # Create a temporary file with the correct extension
+    suffix = f".{file.name.split('.')[-1]}"
+    with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as temp_file:
+        # Copy the uploaded file content to the temporary file
+        shutil.copyfile(file.path, temp_file.name)
+        print(f"Created temporary file at: {temp_file.name}")
+        
+        # Create appropriate loader
+        if file.name.lower().endswith('.pdf'):
+            loader = PDFLoader(temp_file.name)
+        else:
+            loader = TextFileLoader(temp_file.name)
+            
+        try:
+            # Load and process the documents
+            documents = loader.load_documents()
+            texts = text_splitter.split_texts(documents)
+            return texts
+        finally:
+            # Clean up the temporary file
             try:
-                
-                # read file and extract imports
-                file_content = read_python_file(file_path)
-                imports = extract_imports(file_content, file_path)
-
-                print(f'Done reading file')
-
-                # Define describe packages graph
-                search_packages_tools = [search_pypi]
-                describe_imports_llm = ChatOpenAI(model="gpt-4o-mini")
-                # describe_imports_llm = describe_imports_llm.bind_tools(tools = search_packages_tools, tool_choice="required")
-
-                describe_imports_prompt = ChatPromptTemplate.from_messages([
-                        ("system", describe_imports),
-                        ("human", "{imports}")
-                    ])
-
-                describe_imports_chain = (
-                    {"code_language": itemgetter("code_language"), "imports": itemgetter("imports")}
-                    | describe_imports_prompt | describe_imports_llm | StrOutputParser()
-                )
-
-                print(f'done defining imports chain')
-
-
-                # Define imports chain function
-                def call_imports_chain(state):
-                    last_message= state["messages"][-1]
-                    content = json.loads(last_message.content)
-                    chain_input = {"code_language": content['code_language'], 
-                                    "imports": content['imports']}
-                    response = describe_imports_chain.invoke(chain_input)
-                    return {"messages": [AIMessage(content=response)]}
-
-                # bind model to tool or ToolNode
-                imports_tool_node = ToolNode(search_packages_tools)
-
-                # construct graph and compile
-                uncompiled_imports_graph = StateGraph(AgentState)
-                uncompiled_imports_graph.add_node("imports_agent", call_imports_chain)
-                uncompiled_imports_graph.add_node("imports_action", imports_tool_node)
-                uncompiled_imports_graph.set_entry_point("imports_agent")
-                
-                def should_continue(state):
-                    last_message = state["messages"][-1]
-
-                    if last_message.tool_calls:
-                        return "imports_action"
-
-                    return END
-
-                uncompiled_imports_graph.add_conditional_edges(
-                    "imports_agent",
-                    should_continue
-                )
-
-                uncompiled_imports_graph.add_edge("imports_action", "imports_agent")
-
-                compiled_imports_graph = uncompiled_imports_graph.compile()
-
-                print(f'compiled imports graph')
-                # Invoke imports graph
-                initial_state = {
-                    "messages": [{
-                        "role": "human",
-                        "content": json.dumps({
-                            "code_language": "python",
-                            "imports": imports
-                        })
-                    }]
-                }
-
-                # await msg.update(content="Analyzing imports and generating documentation...")
-                msg.content = "Analyzing your code and generating documentation..."
-                await msg.update()
-
-                msg = cl.Message(content="Analyzing your code and generating documentation...")
-                await msg.send()
-
-                result = compiled_imports_graph.invoke(initial_state)
-
-                # Define qdrant Database
-                qdrant_client = QdrantClient(":memory:")
-
-                embedding_model = OpenAIEmbeddings(model="text-embedding-3-small")
-                embedding_dim = 1536
-
-                qdrant_client.create_collection(
-                    collection_name="description_rag_data",
-                    vectors_config=VectorParams(size=embedding_dim, distance=Distance.COSINE),
-                )
-
-                vectorstore = Qdrant(qdrant_client, collection_name="description_rag_data", embeddings=embedding_model)
-
-                # Add packages chunks
-                text = result['messages'][-1].content
-                chunks = [
-                    {"type": "Imported Packages", "name": "Imported Packages", "content": text},
-                    #{"type": "Source Code", "name": "Source Code", "content": file_content},
-                    
-                ]
-
-                docs = [
-                    Document(
-                        page_content=f"{chunk['type']} - {chunk['name']} - {chunk['content']}",  # Content for the model
-                        metadata={**chunk}  # Store metadata, but don't put embeddings here
-                    )
-                    for chunk in chunks
-                ]
-                vectorstore.add_documents(docs)
-                qdrant_retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
-
-                print('done adding docs to DB')
-                #define documenter chain
-                documenter_llm = ChatOpenAI(model="gpt-4o-mini")
-                documenter_llm_prompt = ChatPromptTemplate.from_messages([
-                    ("system", documenter_prompt),
-                ])
-                documenter_chain = (
-                    {"context": itemgetter("context")}
-                    | documenter_llm_prompt
-                    | documenter_llm
-                    | StrOutputParser()
-                )
-
-                print('done defining documenter chain')
-                #extract description chunks from database
-                collection_name = "description_rag_data"
-                all_points = qdrant_client.scroll(collection_name=collection_name, limit=1000)[0]  # Adjust limit if needed
-                one_chunk = all_points[0].payload
-                input_text = f"type: {one_chunk['metadata']['type']} \nname: {one_chunk['metadata']['name']} \ncontent: {one_chunk['metadata']['content']}"
-
-                print('done extracting chunks form DB')
-
-                document_response = documenter_chain.invoke({"context": input_text})
-
-                print('done invoking documenter chain and will write in docx')
-                # write packages description in word file
-                document_file_path  = write_to_docx(document_response)
+                os.unlink(temp_file.name)
+            except Exception as e:
+                print(f"Error cleaning up temporary file: {e}")
 
-                print('done writing docx file')
-                # Set up Main Chain for chat
-                main_llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
 
+@cl.on_chat_start
+async def on_chat_start():
+    files = None
 
-                main_llm_prompt = ChatPromptTemplate.from_messages([
-                    ("system", main_prompt),
-                    ("human", "{query}")
-                ])
+    # Wait for the user to upload a file
+    while files == None:
+        files = await cl.AskFileMessage(
+            content="Please upload a Text or PDF file to begin! test",
+            accept=["text/plain", "application/pdf"],
+            max_size_mb=2,
+            timeout=180,
+        ).send()
 
-                main_chain = (
-                    {"context": itemgetter("query") | qdrant_retriever, "code_language": itemgetter("code_language"), "query": itemgetter("query"), }
-                    | main_llm_prompt
-                    | main_llm
-                    | StrOutputParser()
-                )
+    file = files[0]
 
-                print('done defining main chain')
-                # Present download button for the document
-                elements = [
-                    cl.File(
-                        name="documentation.docx",
-                        path=document_file_path,
-                        display="inline"
-                    )
-                ]
-                print('done defining elements')
-                msg.content = "✅ Your Python file has been processed! You can download the documentation file below. How can I help you with your code?"
-                msg.elements = elements
-                await msg.update()
-                
-            except Exception as e:
-                msg.content = f"❌ Error processing file: {str(e)}"
-                await msg.update()
+    msg = cl.Message(
+        content=f"Processing `{file.name}`..."
+    )
+    await msg.send()
 
-        
-        else:
-            await cl.Message(content="Please upload a Python (.py) file.").send()
+    # load the file
+    texts = process_file(file)
 
-    # Handle chat messages if file has been processed
-    elif processed_file_path and main_chain:
-        user_input = message.content
-        # Send thinking message
-        msg = cl.Message(content="Thinking...")
-        await msg.send()
-
-        try:
-            # Use main_chain to answer the query
-            # invoke main chain
-            inputs = {
-                'code_language': 'Python',
-                'query': user_input
-            }
-
-            response = main_chain.invoke(inputs)
-
-            # Update with the response
-            msg.content = response
-            await msg.update()
+    print(f"Processing {len(texts)} text chunks")
 
+    # Create a dict vector store
+    vector_db = VectorDatabase()
+    vector_db = await vector_db.abuild_from_list(texts)
+    
+    chat_openai = ChatOpenAI()
 
-        except Exception as e:
-            msg.content = f"❌ Error processing your question: {str(e)}"
-            await msg.update()
+    # Create a chain
+    retrieval_augmented_qa_pipeline = RetrievalAugmentedQAPipeline(
+        vector_db_retriever=vector_db,
+        llm=chat_openai
+    )
+    
+    # Let the user know that the system is ready
+    msg.content = f"Processing `{file.name}` done. You can now ask questions!"
+    await msg.update()
 
+    cl.user_session.set("chain", retrieval_augmented_qa_pipeline)
 
 
-    else:
-        await cl.Message(content="Please upload a Python file first before asking questions.").send()
+@cl.on_message
+async def main(message):
+    chain = cl.user_session.get("chain")
 
+    msg = cl.Message(content="")
+    result = await chain.arun_pipeline(message.content)
 
-@cl.on_stop
-def on_stop():
-    global processed_file_path
-    # Clean up temporary files
-    if processed_file_path and os.path.exists(os.path.dirname(processed_file_path)):
-        shutil.rmtree(os.path.dirname(processed_file_path))
+    async for stream_resp in result["response"]:
+        await msg.stream_token(stream_resp)
 
+    await msg.send()

code_analysis.py

@@ -1,31 +0,0 @@
-
-def read_python_file(file_path):
-    try:
-        with open(file_path, 'r', encoding='utf-8') as f:
-            content = f.read()
-        return content
-    except FileNotFoundError:
-        print(f"File not found: {file_path}")
-        raise
-    except IOError as e:
-        print(f"Error reading file {file_path}: {str(e)}")
-        raise
-    except Exception as e:
-        print(f"Unexpected error reading file {file_path}: {str(e)}")
-        raise
-
-def extract_imports(code, file_path):
-    try:
-            
-        # Split into lines and find imports
-        import_lines = []
-        for line in code.split('\n'):
-            line = line.strip()
-            if line.startswith('import ') or line.startswith('from '):
-                import_lines.append(line)
-                
-        return import_lines
-        
-    except Exception as e:
-        print(f"Error extracting imports from file {file_path}: {str(e)}")
-        return []

prompts.py

@@ -1,59 +0,0 @@
-describe_imports = """You are an expert {code_language} developer.
-Your will be given code lines that import packages. 
-Your role is to give a brief description of each package
-
-You have access to the following tool and you MUST use it:
-search_pypi: Use this to get information about Python packages from PyPI.
-
-For each import:
-1. Extract the main package name
-2. Use the search_pypi tool to get package information by calling "search_pypi(package_name)"
-3. Combine the information into a clear description
-4. If the retuned value of tool is empty use your own knowledge
-5. If you have no knowledge for this package then it's description should be "I don't know details about this package"
-
-You must respond in the following JSON format:
-{{"Imported_Packages": [
-    {{"name": "package1", "desc": "brief description of package1"}},
-    {{"name": "package2", "desc": "brief description of package2"}}
-]}}
-
-Rules for the output:
-1. Use valid JSON format
-2. Package names should be the exact names from the imports
-3. Descriptions should be brief and clear
-4. Do not include any text outside the JSON structure
-"""
-
-documenter_prompt = """You are an expert code documenter.
-Your role is to write a well structured document that describes code functionality.
-
-From the given context:
-1- type: is the type of the code block (funciton, class, ..)
-2- name: is the name of the code block
-3- content: is the description of the code block
-
-Instructions:
-Write a docx document with the following structure Heading 1(type) -> Heading 2(name) -> content
-
-Rules for the output:
-1. Don't write information out of context
-2. If needed, structure long responses in lists and sections
-
-<context>
-{context}
-</context>
-"""
-
-main_prompt = """You are an expert {code_language} developer.
-Your role is to answer user's questions about code and its description that will be given to you in context.
-
-Rules for the output:
-1. Don't answer out of context questions.
-2. Provide a single, clear response using only the given context.
-3. If needed, structure long responses in lists and sections.
-
-<context>
-{context}
-</context>
-"""

requirements.txt

@@ -1,106 +0,0 @@
-aiofiles==23.2.1
-aiohappyeyeballs==2.4.6
-aiohttp==3.11.12
-aiosignal==1.3.2
-annotated-types==0.7.0
-anyio==4.8.0
-async-timeout==4.0.3
-asyncer==0.0.7
-attrs==25.1.0
-bidict==0.23.1
-Brotli==1.1.0
-certifi==2025.1.31
-chainlit==2.2.1
-charset-normalizer==3.4.1
-chevron==0.14.0
-click==8.1.8
-dataclasses-json==0.6.7
-Deprecated==1.2.18
-distro==1.9.0
-docx==0.2.4
-fastapi==0.115.8
-filetype==1.2.0
-frozenlist==1.5.0
-googleapis-common-protos==1.68.0
-greenlet==3.1.1
-grpcio==1.70.0
-grpcio-tools==1.70.0
-h11==0.14.0
-h2==4.2.0
-hpack==4.1.0
-httpcore==1.0.7
-httpx==0.28.1
-httpx-sse==0.4.0
-hyperframe==6.1.0
-idna==3.10
-importlib_metadata==8.5.0
-jiter==0.8.2
-jsonpatch==1.33
-jsonpointer==3.0.0
-langchain==0.3.15
-langchain-community==0.3.15
-langchain-core==0.3.31
-langchain-openai==0.3.1
-langchain-qdrant==0.2.0
-langchain-text-splitters==0.3.5
-langgraph==0.2.74
-langgraph-checkpoint==2.0.16
-langgraph-sdk==0.1.51
-langsmith==0.3.8
-Lazify==0.4.0
-literalai==0.1.103
-lxml==5.3.1
-marshmallow==3.26.1
-msgpack==1.1.0
-multidict==6.1.0
-mypy-extensions==1.0.0
-numpy==1.26.4
-openai==1.63.2
-opentelemetry-api==1.29.0
-opentelemetry-exporter-otlp==1.29.0
-opentelemetry-exporter-otlp-proto-common==1.29.0
-opentelemetry-exporter-otlp-proto-grpc==1.29.0
-opentelemetry-exporter-otlp-proto-http==1.29.0
-opentelemetry-instrumentation==0.50b0
-opentelemetry-proto==1.29.0
-opentelemetry-sdk==1.29.0
-opentelemetry-semantic-conventions==0.50b0
-orjson==3.10.15
-pillow==11.1.0
-portalocker==2.10.1
-propcache==0.2.1
-protobuf==5.29.3
-pydantic==2.10.6
-pydantic-settings==2.7.1
-pydantic_core==2.27.2
-PyJWT==2.10.1
-python-docx==1.1.2
-python-dotenv==1.0.1
-python-engineio==4.11.2
-python-multipart==0.0.18
-python-socketio==5.12.1
-PyYAML==6.0.2
-qdrant-client==1.13.2
-regex==2024.11.6
-requests==2.32.3
-requests-toolbelt==1.0.0
-simple-websocket==1.1.0
-sniffio==1.3.1
-socksio==1.0.0
-SQLAlchemy==2.0.38
-starlette==0.41.3
-syncer==2.0.3
-tenacity==9.0.0
-tiktoken==0.9.0
-tomli==2.2.1
-tqdm==4.67.1
-typing-inspect==0.9.0
-uptrace==1.29.0
-urllib3==2.3.0
-uvicorn==0.34.0
-watchfiles==0.20.0
-wrapt==1.17.2
-wsproto==1.2.0
-yarl==1.18.3
-zipp==3.21.0
-zstandard==0.23.0

states.py

@@ -1,7 +0,0 @@
-from typing_extensions import List, TypedDict
-from typing import TypedDict, Annotated
-from langgraph.graph.message import add_messages
-
-
-class AgentState(TypedDict):
-  messages: Annotated[list, add_messages]

tools.py

@@ -1,51 +0,0 @@
-from langchain_core.tools import Tool, tool
-import requests
-import json
-from docx import Document
-import re
-
-
-@tool
-def search_pypi(package_name: str) -> str:
-    """Search PyPI for Python package information. Input should be the package name.
-    Args: 
-        package_name: name of the package 
-    """
-    print(f"Tool called for package: {package_name}")
-    base_url = "https://pypi.org/pypi"
-    try:
-        try:
-            response = requests.get(f"{base_url}/{package_name}/json")
-            response.raise_for_status()
-            info = response.json()
-        except requests.RequestException as e:
-            raise Exception(f"Error fetching PyPI info for {package_name}: {str(e)}")
-        result =  json.dumps({
-            "name": info["info"]["name"],
-            "summary": info["info"]["summary"],
-        })
-        print(f"Tool result: {result}")
-        return result
-    except Exception as e:
-        return f"Could not find package information: {str(e)}"
-    
-# @tool
-def write_to_docx(documentation_text: str) -> str:
-    """
-    Writes the AI-generated documentation to a .docx file and returns the file path.
-    """
-    doc = Document()
-    # doc.add_heading("Code Documentation", level=1)
-
-    lines = documentation_text.split("\n")
-    for line in lines:
-        if line.startswith("# "):  # Section Heading
-            doc.add_heading(line[2:], level=1)
-        elif line.startswith("## "):  # Subsection Heading
-            doc.add_heading(line[3:], level=2)
-        else:  # Normal paragraph
-            doc.add_paragraph(line)
-
-    file_path = "generated_documentation.docx"
-    doc.save(file_path)
-    return file_path