replace project

Dockerfile

@@ -1,31 +1,73 @@
+# 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
 
-# Get a distribution that has uv already installed
-FROM ghcr.io/astral-sh/uv:python3.13-bookworm-slim
+# 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 . .
 
-# Add user - this is the user that will run the app
-# If you do not set user, the app will run as root (undesirable)
+# # 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
 RUN useradd -m -u 1000 user
-USER user
 
-# Set the home directory and path
+# Set environment variables
 ENV HOME=/home/user \
-    PATH=/home/user/.local/bin:$PATH        
+    PATH=/home/user/.local/bin:$PATH
 
-ENV UVICORN_WS_PROTOCOL=websockets
+# 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
 
-# Set the working directory
-WORKDIR $HOME/app
+# 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
 
-# Copy the app to the container
-COPY --chown=user . $HOME/app
+COPY chainlit.md .
 
-# Install the dependencies
-# RUN uv sync --frozen
-RUN uv sync
 
-# Expose the port
+# Expose port
 EXPOSE 7860
 
-# Run the app
-CMD ["uv", "run", "chainlit", "run", "app.py", "--host", "0.0.0.0", "--port", "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"]

app.py

@@ -1,139 +1,304 @@
 import os
-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 getpass
+from operator import itemgetter
+from typing import List, Dict
+import json
+import requests
 
-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)
+#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
 
-class RetrievalAugmentedQAPipeline:
-    def __init__(self, llm: ChatOpenAI(), vector_db_retriever: VectorDatabase) -> None:
-        self.llm = llm
-        self.vector_db_retriever = vector_db_retriever
+import chainlit as cl
+import tempfile
+import shutil
 
-    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"
 
-        formatted_system_prompt = system_role_prompt.create_message()
 
-        formatted_user_prompt = user_role_prompt.create_message(question=user_query, context=context_prompt)
+#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
 
-        async def generate_response():
-            async for chunk in self.llm.astream([formatted_system_prompt, formatted_user_prompt]):
-                yield chunk
+os.environ["CHAINLIT_DISABLE_WEBSOCKETS"] = "true"
 
-        return {"response": generate_response(), "context": context_list}
 
-text_splitter = CharacterTextSplitter()
+# Global variables to store processed data
+processed_file_path = None
+document_file_path = None
+vectorstore = None
+main_chain = None
+qdrant_client = None
 
+@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()
 
-def process_file(file: AskFileResponse):
-    import tempfile
-    import shutil
-    
-    print(f"Processing file: {file.name}")
+@cl.on_message
+async def on_message(message: cl.Message):
+    global processed_file_path, document_file_path, vectorstore, main_chain, qdrant_client
     
-    # 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
+    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()
+
+            print(f'file element \n {file_element} \n')
+
+            # Save uploaded file to a temporary location
+            temp_dir = tempfile.mkdtemp()
+            file_path = os.path.join(temp_dir, file_element.name)
+
+            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
+
             try:
-                os.unlink(temp_file.name)
-            except Exception as e:
-                print(f"Error cleaning up temporary file: {e}")
+                
+                # read file and extract imports
+                file_content = read_python_file(file_path)
+                imports = extract_imports(file_content, file_path)
 
+                print(f'Done reading file')
 
-@cl.on_chat_start
-async def on_chat_start():
-    files = None
+                # 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")
 
-    # 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()
+                describe_imports_prompt = ChatPromptTemplate.from_messages([
+                        ("system", describe_imports),
+                        ("human", "{imports}")
+                    ])
 
-    file = files[0]
+                describe_imports_chain = (
+                    {"code_language": itemgetter("code_language"), "imports": itemgetter("imports")}
+                    | describe_imports_prompt | describe_imports_llm | StrOutputParser()
+                )
 
-    msg = cl.Message(
-        content=f"Processing `{file.name}`..."
-    )
-    await msg.send()
+                print(f'done defining imports chain')
 
-    # load the file
-    texts = process_file(file)
 
-    print(f"Processing {len(texts)} text chunks")
+                # 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)]}
 
-    # Create a dict vector store
-    vector_db = VectorDatabase()
-    vector_db = await vector_db.abuild_from_list(texts)
-    
-    chat_openai = ChatOpenAI()
+                # bind model to tool or ToolNode
+                imports_tool_node = ToolNode(search_packages_tools)
 
-    # 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()
+                # 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]
 
-    cl.user_session.set("chain", retrieval_augmented_qa_pipeline)
+                    if last_message.tool_calls:
+                        return "imports_action"
 
+                    return END
 
-@cl.on_message
-async def main(message):
-    chain = cl.user_session.get("chain")
+                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)
+
+                print('done writing docx file')
+                # Set up Main Chain for chat
+                main_llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
+
+
+                main_llm_prompt = ChatPromptTemplate.from_messages([
+                    ("system", main_prompt),
+                    ("human", "{query}")
+                ])
+
+                main_chain = (
+                    {"context": itemgetter("query") | qdrant_retriever, "code_language": itemgetter("code_language"), "query": itemgetter("query"), }
+                    | main_llm_prompt
+                    | main_llm
+                    | StrOutputParser()
+                )
+
+                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()
+
+        
+        else:
+            await cl.Message(content="Please upload a Python (.py) file.").send()
+
+    # 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()
+
+
+        except Exception as e:
+            msg.content = f"❌ Error processing your question: {str(e)}"
+            await msg.update()
+
+
+
+    else:
+        await cl.Message(content="Please upload a Python file first before asking questions.").send()
 
-    msg = cl.Message(content="")
-    result = await chain.arun_pipeline(message.content)
 
-    async for stream_resp in result["response"]:
-        await msg.stream_token(stream_resp)
+@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))
 
-    await msg.send()

code_analysis.py

@@ -0,0 +1,31 @@
+
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,106 @@
+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

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

@@ -0,0 +1,51 @@
+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