Merge branch 'tests' of https://github.com/luanpoppe/vella-backend

.env.example

@@ -11,4 +11,6 @@ LLAMA_CLOUD_API_KEY_PEIXE=""
 DEEPSEEKK_API_KEY=""
 GOOGLE_API_KEY_PEIXE=""
 SENTRY_DSN=""
-AMBIENTE="testes"
+AMBIENTE="testes"
+GOOGLE_APPLICATION_CREDENTIALS="" # Só é necessário em ambiente de desenvolvimento que não esteja usando docker
+GCP_CREDENTIALS_JSON_CONTENT="Conteúdo inteiro do arquivo vella_gcp_luan_credentials.json" # Em produção, tem que conter todo o conteúdo do arquivo de credentials. Localmente, não precisa existir

.gitignore

@@ -173,5 +173,4 @@ cython_debug/
 #.idea/
 
 # End of https://www.toptal.com/developers/gitignore/api/django
-
 vella_gcp_luan_credentials.json

Dockerfile

@@ -3,6 +3,10 @@ FROM python:3.12
 # Instalação necessária para converter arquivos .doc
 RUN apt-get update && apt-get install -y antiword
 
+# Copy the entrypoint script and make it executable
+COPY entrypoint.sh /entrypoint.sh
+RUN chmod +x /entrypoint.sh
+
 RUN useradd -m -u 1000 user
 USER user
 ENV PATH="/home/user/.local/bin:$PATH"
@@ -23,6 +27,10 @@ RUN pip install --no-cache-dir -r requirements.txt
 RUN python manage.py collectstatic --noinput
 
 RUN pip install uvicorn
+
+# Set the entrypoint to our script
+ENTRYPOINT ["/entrypoint.sh"]
+
 CMD ["uvicorn", "setup.asgi:application", "--host", "0.0.0.0", "--port", "7860"]
 
 # ENTRYPOINT ["python", "manage.py", "runserver"]

_utils/Handle_Files_Class.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+from typing import List, Tuple
+
+from _utils.langchain_utils.Splitter_class import Splitter
+from _utils.models.gerar_documento import DocumentChunk
+
+
+@dataclass
+class HandleFilesClass:
+    async def get_full_text_and_all_PDFs_chunks(
+        self,
+        listaPDFs: List[str],
+        splitterObject: Splitter,
+        should_use_llama_parse: bool,
+        isBubble: bool,
+    ) -> Tuple[List[DocumentChunk], List[str]]:
+        all_PDFs_chunks: List[DocumentChunk] = []
+
+        pages: List[str] = []
+
+        # Load and process document
+        for pdf_path in listaPDFs:
+            chunks, pages = await splitterObject.load_and_split_document(
+                pdf_path, should_use_llama_parse, isBubble
+            )
+            all_PDFs_chunks = all_PDFs_chunks + chunks
+
+        return all_PDFs_chunks, pages

_utils/Utils_Class.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+from typing import List
+
+from _utils.Handle_Files_Class import HandleFilesClass
+
+
+@dataclass
+class UtilsClass:
+    lista_pdfs: List[str] | None = None
+    handle_files = HandleFilesClass()

_utils/axiom_logs.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+
+from setup.logging import Axiom
+
+
+@dataclass
+class AxiomLogs:
+    axiom: Axiom
+
+    def texto_completo_pdf(self, full_text_as_array):
+        self.axiom.send_axiom(
+            f"INÍCIO DO TEXTO COMPLETO DOS PDFS: {full_text_as_array[0:5]}"
+        )
+
+    def resumo_inicial_processo(self, response_auxiliar_summary):
+        self.axiom.send_axiom(
+            f"RESUMO INICIAL DO PROCESSO: {response_auxiliar_summary}"
+        )
+
+    def inicio_requisicao_contextual(self):
+        self.axiom.send_axiom("COMEÇANDO A FAZER AS REQUISIÇÕES DO CONTEXTUAL")
+
+    def fim_requisicao_contextual(self):
+        self.axiom.send_axiom("TERMINOU DE FAZER TODAS AS REQUISIÇÕES DO CONTEXTUAL")
+
+    def chunks_inicialmente(self, chunks_processados):
+        self.axiom.send_axiom(f"CHUNKS PROCESSADOS INICIALMENTE: {chunks_processados}")

_utils/custom_exception_handler.py

@@ -44,7 +44,7 @@ def custom_exception_handler(exc, context):
     return response
 
 
-def custom_exception_handler_wihout_api_handler(
+def custom_exception_handler_without_api_handler(
     error, serializer: Union[GerarDocumentoSerializerData, Any], axiom_instace: Axiom
 ):
     bahia_tz = pytz.timezone("America/Bahia")

_utils/files/ragas_testset.csv

@@ -1,18 +0,0 @@
-position,user_input,reference,response,retrieved_contexts
-0,What are the global implications of the USA Supreme Court ruling on abortion?,"The global implications of the USA Supreme Court ruling on abortion are significant. The ruling has led to limited or no access to abortion for one in three women and girls of reproductive age in states where abortion access is restricted. These states also have weaker maternal health support, higher maternal death rates, and higher child poverty rates. Additionally, the ruling has had an impact beyond national borders due to the USA's geopolitical and cultural influence globally. Organizations and activists worldwide are concerned that the ruling may inspire anti-abortion legislative and policy attacks in other countries. The ruling has also hindered progressive law reform and the implementation of abortion guidelines in certain African countries. Furthermore, the ruling has created a chilling effect in international policy spaces, empowering anti-abortion actors to undermine human rights protections.","The global implications of the USA Supreme Court ruling on abortion can be significant, as it sets a precedent for other countries and influences the global discourse on reproductive rights. Here are some potential implications:
-
-1. Influence on other countries: The Supreme Court's ruling can serve as a reference point for other countries grappling with their own abortion laws. It can provide legal arguments and reasoning that advocates for reproductive rights can use to challenge restrictive abortion laws in their respective jurisdictions.
-
-2. Strengthening of global reproductive rights movements: A favorable ruling by the Supreme Court can energize and empower reproductive rights movements worldwide. It can serve as a rallying point for activists and organizations advocating for women's rights, leading to increased mobilization and advocacy efforts globally.
-
-3. Counteracting anti-abortion movements: Conversely, a ruling that restricts abortion rights can embolden anti-abortion movements globally. It can provide legitimacy to their arguments and encourage similar restrictive measures in other countries, potentially leading to a rollback of existing reproductive rights.
-
-4. Impact on international aid and policies: The Supreme Court's ruling can influence international aid and policies related to reproductive health. It can shape the priorities and funding decisions of donor countries and organizations, potentially leading to increased support for reproductive rights initiatives or conversely, restrictions on funding for abortion-related services.
-
-5. Shaping international human rights standards: The ruling can contribute to the development of international human rights standards regarding reproductive rights. It can influence the interpretation and application of existing human rights treaties and conventions, potentially strengthening the recognition of reproductive rights as fundamental human rights globally.
-
-6. Global health implications: The Supreme Court's ruling can have implications for global health outcomes, particularly in countries with restrictive abortion laws. It can impact the availability and accessibility of safe and legal abortion services, potentially leading to an increase in unsafe abortions and related health complications.
-
-It is important to note that the specific implications will depend on the nature of the Supreme Court ruling and the subsequent actions taken by governments, activists, and organizations both within and outside the United States.","[""- In 2022, the USA Supreme Court handed down a decision ruling that overturned 50 years of jurisprudence recognizing a constitutional right to abortion.\n- This decision has had a massive impact: one in three women and girls of reproductive age now live in states where abortion access is either totally or near-totally inaccessible.\n- The states with the most restrictive abortion laws have the weakest maternal health support, higher maternal death rates, and higher child poverty rates.\n- The USA Supreme Court ruling has also had impacts beyond national borders due to the geopolitical and cultural influence wielded by the USA globally and the aid it funds.\n- SRR organizations and activists across the world have expressed fear about the ruling laying the groundwork for anti-abortion legislative and policy attacks in other countries.\n- Advocates have also observed the ruling's impact on progressive law reform and the stalling of the adoption and enforcement of abortion guidelines in certain African countries.\n- The ruling has created a chilling effect in international policy spaces, emboldening anti-abortion state and non-state actors to undermine human rights protections.""
- 'The USA Supreme Court ruling on abortion has sparked intense debates and discussions not only within the country but also around the world. Many countries look to the United States as a leader in legal and social issues, so the decision could potentially influence the policies and attitudes towards abortion in other nations.'
- ""The ruling may also impact international organizations and non-governmental groups that work on reproductive rights and women's health issues. Depending on the outcome, there could be shifts in funding, advocacy efforts, and collaborations with American counterparts, leading to ripple effects in the global fight for reproductive justice.""]"

_utils/gerar_documento.py

@@ -1,31 +1,11 @@
 import os
-from langchain_core.messages import HumanMessage
-from typing import Any, Union, cast
-from _utils.langchain_utils.LLM_class import LLM
-from _utils.bubble_integrations.enviar_resposta_final import enviar_resposta_final
-from _utils.custom_exception_handler import custom_exception_handler_wihout_api_handler
-from _utils.gerar_documento_utils.prompts import (
-    prompt_gerar_query_dinamicamente,
-)
+from typing import Any, Union
+from _utils.custom_exception_handler import custom_exception_handler_without_api_handler
+from rest_framework.response import Response
 from _utils.gerar_documento_utils.GerarDocumento import (
     GerarDocumento,
 )
-from _utils.gerar_documento_utils.contextual_retriever import (
-    ContextualRetriever,
-)
-from _utils.gerar_documento_utils.utils import (
-    generate_document_title,
-    gerar_resposta_compilada,
-    get_full_text_and_all_PDFs_chunks,
-    get_response_from_auxiliar_contextual_prompt,
-)
-from _utils.models.gerar_documento import (
-    RetrievalConfig,
-)
-import markdown
 
-from _utils.langchain_utils.Prompt_class import Prompt
-from _utils.utils import convert_markdown_to_HTML
 from gerar_documento.serializer import (
     GerarDocumentoComPDFProprioSerializer,
     GerarDocumentoComPDFProprioSerializerData,
@@ -47,130 +27,39 @@ async def gerar_documento(
     listaPDFs,
     axiom_instance: Axiom,
     isBubble=False,
-):
+) -> Response | dict[str, Any]:
     try:
-        contextual_retriever = ContextualRetriever(serializer)
-
-        # Initialize enhanced summarizer
-        summarizer = GerarDocumento(serializer, axiom_instance)
-
-        all_PDFs_chunks, full_text_as_array = await get_full_text_and_all_PDFs_chunks(
-            listaPDFs,
-            summarizer.splitter,
-            serializer.should_use_llama_parse,
-            isBubble,
-        )
-        axiom_instance.send_axiom(
-            f"INÍCIO DO TEXTO COMPLETO DOS PDFS: {full_text_as_array[0:5]}"
-        )
-
-        is_contextualized_chunk = serializer.should_have_contextual_chunks
-
-        if is_contextualized_chunk:
-            response_auxiliar_summary = (
-                await get_response_from_auxiliar_contextual_prompt(full_text_as_array)
-            )
-            axiom_instance.send_axiom(
-                f"RESUMO INICIAL DO PROCESSO: {response_auxiliar_summary}"
-            )
-
-            axiom_instance.send_axiom("COMEÇANDO A FAZER AS REQUISIÇÕES DO CONTEXTUAL")
-            contextualized_chunks = await contextual_retriever.contextualize_all_chunks(
-                all_PDFs_chunks, response_auxiliar_summary, axiom_instance
-            )
-            axiom_instance.send_axiom(
-                "TERMINOU DE FAZER TODAS AS REQUISIÇÕES DO CONTEXTUAL"
-            )
-            chunks_processados = contextualized_chunks
-            axiom_instance.send_axiom(
-                f"CHUNKS PROCESSADOS INICIALMENTE: {chunks_processados}"
-            )
-        else:
-            chunks_processados = all_PDFs_chunks
-
-        llm = LLM()
-        prompt_para_gerar_query_dinamico = prompt_gerar_query_dinamicamente(
-            cast(str, response_auxiliar_summary)
-        )
-
-        axiom_instance.send_axiom(
-            "COMEÇANDO REQUISIÇÃO PARA GERAR O QUERY DINAMICAMENTE DO VECTOR STORE"
-        )
-        query_gerado_dinamicamente_para_o_vector_store = (
-            await llm.google_gemini_ainvoke(
-                prompt_para_gerar_query_dinamico, "gemini-2.0-flash"
-            )
-        )
-
-        axiom_instance.send_axiom(
-            f"query_gerado_dinamicamente_para_o_vector_store: {query_gerado_dinamicamente_para_o_vector_store.content}",
-        )
-
-        # Create enhanced vector store and BM25 index
-        vector_store, bm25, chunk_ids = (
-            summarizer.vector_store.create_enhanced_vector_store(
-                chunks_processados, is_contextualized_chunk, axiom_instance
-            )
-        )
-
-        llm_ultimas_requests = serializer.llm_ultimas_requests
-        axiom_instance.send_axiom("COMEÇANDO A FAZER ÚLTIMA REQUISIÇÃO")
-        structured_summaries = await summarizer.gerar_documento_final(
-            vector_store,
-            bm25,
-            chunk_ids,
-            llm_ultimas_requests,
-            cast(
-                str, query_gerado_dinamicamente_para_o_vector_store.content
-            ),  # prompt_auxiliar_SEM_CONTEXT,
-        )
-        axiom_instance.send_axiom("TERMINOU DE FAZER A ÚLTIMA REQUISIÇÃO")
+        summarizer = GerarDocumento(serializer, isBubble, axiom_instance)
+        summarizer.lista_pdfs = listaPDFs
 
-        if not isinstance(structured_summaries, list):
-            from rest_framework.response import Response
+        await summarizer.get_text_and_pdf_chunks()
 
-            return Response({"erro": structured_summaries})
+        await summarizer.get_response_from_auxiliar_contextual_prompt()
 
-        texto_completo = summarizer.resumo_gerado + "\n\n"
+        await summarizer.generate_chunks_processados()
 
-        for x in structured_summaries:
-            texto_completo = texto_completo + x["content"] + "\n"
-            x["source"]["text"] = x["source"]["text"][0:200]
-            x["source"]["context"] = x["source"]["context"][0:200]
+        await summarizer.generate_query_for_vector_store()
+
+        await summarizer.create_enhanced_vector_store()
+
+        structured_summaries = await summarizer.do_last_requests()
+
+        if not isinstance(structured_summaries, list):
+            return Response({"erro": structured_summaries})
 
-        texto_completo_como_html = convert_markdown_to_HTML(texto_completo).replace(
-            "resposta_segunda_etapa:", "<br><br>"
-        )
-        axiom_instance.send_axiom(
-            f"texto_completo_como_html: {texto_completo_como_html}"
-        )
+        await summarizer.generate_complete_text()
 
-        if is_contextualized_chunk:
-            prompt_titulo_do_documento = response_auxiliar_summary
-        else:
-            prompt_titulo_do_documento = texto_completo_como_html
-        titulo_do_documento = await generate_document_title(
-            cast(str, prompt_titulo_do_documento)
-        )
+        await summarizer.get_document_title()
 
         if isBubble:
-            axiom_instance.send_axiom("COMEÇANDO A REQUISIÇÃO FINAL PARA O BUBBLE")
-            enviar_resposta_final(
-                serializer.doc_id,  # type: ignore
-                serializer.form_response_id,  # type: ignore
-                serializer.version,  # type: ignore
-                texto_completo_como_html,
-                False,
-                cast(str, titulo_do_documento),
-            )
-            axiom_instance.send_axiom("TERMINOU A REQUISIÇÃO FINAL PARA O BUBBLE")
+            await summarizer.send_to_bubble()
 
         return {
-            "texto_completo": texto_completo_como_html,
-            "titulo_do_documento": titulo_do_documento,
+            "texto_completo": summarizer.texto_completo_como_html,
+            "titulo_do_documento": summarizer.titulo_do_documento,
             "resultado": structured_summaries,
-            "parametros-utilizados": gerar_resposta_compilada(serializer),
+            "parametros-utilizados": summarizer.gerar_resposta_compilada(),
         }
     except Exception as e:
-        custom_exception_handler_wihout_api_handler(e, serializer, axiom_instance)
+        custom_exception_handler_without_api_handler(e, serializer, axiom_instance)
         raise

_utils/gerar_documento_utils/GerarDocumento.py

@@ -1,12 +1,23 @@
 from dataclasses import dataclass
-import os
+from langchain_core.messages import HumanMessage
 from typing import Any, List, Dict, Literal, Tuple, Optional, Union, cast
 
 from pydantic import SecretStr
+from _utils.Utils_Class import UtilsClass
+from _utils.axiom_logs import AxiomLogs
+from _utils.bubble_integrations.enviar_resposta_final import enviar_resposta_final
+from _utils.gerar_documento_utils.contextual_retriever import ContextualRetriever
+from _utils.gerar_documento_utils.llm_calls import agemini_answer
+from _utils.gerar_documento_utils.prompts import (
+    create_prompt_auxiliar_do_contextual_prompt,
+    prompt_gerar_query_dinamicamente,
+    prompt_para_gerar_titulo,
+)
 from _utils.langchain_utils.Chain_class import Chain
-from _utils.langchain_utils.LLM_class import LLM
+from _utils.langchain_utils.LLM_class import LLM, Google_llms
 from _utils.langchain_utils.Prompt_class import Prompt
 from _utils.langchain_utils.Vector_store_class import VectorStore
+from _utils.utils import convert_markdown_to_HTML
 from gerar_documento.serializer import (
     GerarDocumentoComPDFProprioSerializerData,
     GerarDocumentoSerializerData,
@@ -21,13 +32,17 @@ from setup.easy_imports import (
 )
 import logging
 from _utils.models.gerar_documento import (
+    ContextualizedChunk,
+    DocumentChunk,
     RetrievalConfig,
 )
 from cohere import Client
 from _utils.langchain_utils.Splitter_class import Splitter
 import time
-
+from setup.tokens import openai_api_key, cohere_api_key
 from setup.logging import Axiom
+import tiktoken
+from setup.environment import default_model
 
 
 def reciprocal_rank_fusion(result_lists, weights=None):
@@ -51,6 +66,10 @@ def reciprocal_rank_fusion(result_lists, weights=None):
 
 @dataclass
 class GerarDocumentoUtils:
+    axiom_instance: Axiom
+    temperature = 0.0
+    model = default_model
+
     def criar_output_estruturado(self, summaries: List[str | Any], sources: Any):
         structured_output = []
         for idx, summary in enumerate(summaries):
@@ -81,35 +100,131 @@ class GerarDocumentoUtils:
         else:
             return documento_gerado
 
-
-class GerarDocumento:
-    openai_api_key = os.environ.get("OPENAI_API_KEY", "")
-    cohere_api_key = os.environ.get("COHERE_API_KEY", "")
-    resumo_gerado = ""
-    gerar_documento_utils = GerarDocumentoUtils()
-
-    def __init__(
+    def create_retrieval_config(
         self,
         serializer: Union[
             GerarDocumentoSerializerData, GerarDocumentoComPDFProprioSerializerData, Any
         ],
-        axiom_instance: Axiom,
     ):
-        self.config = RetrievalConfig(
+        return RetrievalConfig(
             num_chunks=serializer.num_chunks_retrieval,
             embedding_weight=serializer.embedding_weight,
             bm25_weight=serializer.bm25_weight,
             context_window=serializer.context_window,
             chunk_overlap=serializer.chunk_overlap,
         )
+
+    async def checar_se_resposta_vazia_do_documento_final(
+        self, llm_ultimas_requests: str, prompt: str
+    ):
+        llm = self.select_model_for_last_requests(llm_ultimas_requests)  # type: ignore
+        documento_gerado = ""
+        tentativas = 0
+
+        while tentativas < 5 and not documento_gerado:
+            tentativas += 1
+            try:
+                resposta = llm.invoke(prompt)
+                if hasattr(resposta, "content") and resposta.content.strip():  # type: ignore
+                    if isinstance(resposta.content, list):
+                        resposta.content = "\n".join(resposta.content)  # type: ignore
+
+                    documento_gerado = resposta.content.strip()  # type: ignore
+                else:
+                    print(f"Tentativa {tentativas}: resposta vazia ou inexistente.")
+            except Exception as e:
+                llm = self.select_model_for_last_requests("gemini-2.0-flash")
+                print(f"Tentativa {tentativas}: erro ao invocar o modelo: {e}")
+            time.sleep(5)
+
+        if not documento_gerado:
+            try:
+                self.axiom_instance.send_axiom(
+                    "TENTANDO GERAR DOCUMENTO FINAL COM GPT 4o-mini COMO ÚLTIMA TENTATIVA"
+                )
+                documento_gerado = self.ultima_tentativa_requisicao(prompt)
+            except Exception as e:
+                raise Exception(
+                    "Falha ao gerar o documento final na última tentativa."
+                ) from e
+
+        return documento_gerado
+
+    def select_model_for_last_requests(
+        self,
+        llm_ultimas_requests: Literal[
+            "gpt-4o-mini", "deepseek-chat", "gemini-2.0-flash", "gemini-2.5-pro"
+        ],
+    ):
+        llm_instance = LLM()
+        if llm_ultimas_requests == "gpt-4o-mini":
+            llm = ChatOpenAI(
+                temperature=self.temperature,
+                model=self.model,
+                api_key=SecretStr(openai_api_key),
+            )
+        elif llm_ultimas_requests == "deepseek-chat":
+            llm = llm_instance.deepseek()
+        elif llm_ultimas_requests == "gemini-2.0-flash":
+            llm = llm_instance.google_gemini(
+                "gemini-2.0-flash", temperature=self.temperature
+            )
+        elif llm_ultimas_requests == "gemini-2.5-pro":
+            llm = llm_instance.google_gemini(
+                "gemini-2.5-pro-preview-05-06", temperature=self.temperature
+            )
+        elif llm_ultimas_requests == "gemini-2.5-flash":
+            llm = llm_instance.google_gemini(
+                "gemini-2.5-flash-preview-04-17", temperature=self.temperature
+            )
+        return llm
+
+
+class GerarDocumento:
+    lista_pdfs: List[str]
+    should_use_llama_parse: bool
+    all_PDFs_chunks: List[DocumentChunk]
+    full_text_as_array: List[str]
+    isBubble: bool
+    chunks_processados: List[ContextualizedChunk] | List[DocumentChunk]
+    resumo_auxiliar: str
+    gerar_documento_utils: GerarDocumentoUtils
+    utils = UtilsClass()
+    llm = LLM()
+    enhanced_vector_store: tuple[Chroma, BM25Okapi, List[str]]
+    query_gerado_dinamicamente_para_o_vector_store: str
+    structured_output: List[Any]
+    texto_completo_como_html: str
+    titulo_do_documento: str
+    encoding_tiktoken = tiktoken.get_encoding("cl100k_base")
+    serializer: Union[
+        GerarDocumentoSerializerData, GerarDocumentoComPDFProprioSerializerData, Any
+    ]
+
+    def __init__(
+        self,
+        serializer: Union[
+            GerarDocumentoSerializerData, GerarDocumentoComPDFProprioSerializerData, Any
+        ],
+        isBubble: bool,
+        axiom_instance: Axiom,
+    ):
+        self.gerar_documento_utils = GerarDocumentoUtils(axiom_instance)
+        self.gerar_documento_utils.temperature = serializer.gpt_temperature
+        self.config = self.gerar_documento_utils.create_retrieval_config(serializer)
+        self.serializer = serializer
         self.logger = logging.getLogger(__name__)
         # self.prompt_auxiliar = prompt_auxiliar
         self.gpt_model = serializer.model
-        self.gpt_temperature = serializer.gpt_temperature
+        self.llm_temperature = serializer.gpt_temperature
         self.prompt_gerar_documento = serializer.prompt_gerar_documento
+        self.should_use_llama_parse = serializer.should_use_llama_parse
+        self.isBubble = isBubble
+        self.is_contextualized_chunk = serializer.should_have_contextual_chunks
+        self.contextual_retriever = ContextualRetriever(serializer)
+        self.llm_ultimas_requests = serializer.llm_ultimas_requests
 
-        self.openai_api_key = self.openai_api_key
-        self.cohere_client = Client(self.cohere_api_key)
+        self.cohere_client = Client(cohere_api_key)
         self.embeddings = HuggingFaceEmbeddings(model_name=serializer.hf_embedding)
         self.num_k_rerank = serializer.num_k_rerank
         self.model_cohere_rerank = serializer.model_cohere_rerank
@@ -119,6 +234,75 @@ class GerarDocumento:
 
         self.vector_store = VectorStore(serializer.hf_embedding)
         self.axiom_instance: Axiom = axiom_instance
+        self.ax = AxiomLogs(axiom_instance)
+
+    async def get_text_and_pdf_chunks(self):
+        all_PDFs_chunks, full_text_as_array = (
+            await self.utils.handle_files.get_full_text_and_all_PDFs_chunks(
+                self.lista_pdfs,
+                self.splitter,
+                self.should_use_llama_parse,
+                self.isBubble,
+            )
+        )
+        self.ax.texto_completo_pdf(full_text_as_array)
+
+        self.all_PDFs_chunks = all_PDFs_chunks
+        self.full_text_as_array = full_text_as_array
+        return all_PDFs_chunks, full_text_as_array
+
+    async def generate_chunks_processados(self):
+        if self.is_contextualized_chunk:
+            self.ax.inicio_requisicao_contextual()
+            contextualized_chunks = (
+                await self.contextual_retriever.contextualize_all_chunks(
+                    self.all_PDFs_chunks, self.resumo_auxiliar, self.axiom_instance
+                )
+            )
+            self.ax.fim_requisicao_contextual()
+
+        chunks_processados = (
+            contextualized_chunks
+            if self.is_contextualized_chunk
+            else self.all_PDFs_chunks
+        )
+        self.chunks_processados = chunks_processados
+        if len(self.chunks_processados) == 0:
+            self.chunks_processados = self.all_PDFs_chunks
+        self.ax.chunks_inicialmente(self.chunks_processados)
+        return self.chunks_processados
+
+    async def generate_query_for_vector_store(self):
+        prompt_para_gerar_query_dinamico = prompt_gerar_query_dinamicamente(
+            cast(str, self.resumo_auxiliar)
+        )
+
+        self.axiom_instance.send_axiom(
+            "COMEÇANDO REQUISIÇÃO PARA GERAR O QUERY DINAMICAMENTE DO VECTOR STORE"
+        )
+        response = await self.llm.google_gemini_ainvoke(
+            prompt_para_gerar_query_dinamico,
+            "gemini-2.0-flash",
+            temperature=self.llm_temperature,
+        )
+
+        self.query_gerado_dinamicamente_para_o_vector_store = cast(
+            str, response.content
+        )
+
+        self.axiom_instance.send_axiom(
+            f"query_gerado_dinamicamente_para_o_vector_store: {self.query_gerado_dinamicamente_para_o_vector_store}",
+        )
+
+        return self.query_gerado_dinamicamente_para_o_vector_store
+
+    async def create_enhanced_vector_store(self):
+        vector_store, bm25, chunk_ids = self.vector_store.create_enhanced_vector_store(
+            self.chunks_processados, self.is_contextualized_chunk, self.axiom_instance  # type: ignore
+        )
+
+        self.enhanced_vector_store = vector_store, bm25, chunk_ids
+        return vector_store, bm25, chunk_ids
 
     def retrieve_with_rank_fusion(
         self, vector_store: Chroma, bm25: BM25Okapi, chunk_ids: List[str], query: str
@@ -208,40 +392,18 @@ class GerarDocumento:
 
         return sources, contexts
 
-    def select_model_for_last_requests(
-        self,
-        llm_ultimas_requests: Literal[
-            "gpt-4o-mini", "deepseek-chat", "gemini-2.0-flash", "gemini-2.5-pro"
-        ],
-    ):
-        llm_instance = LLM()
-        if llm_ultimas_requests == "gpt-4o-mini":
-            llm = ChatOpenAI(
-                temperature=self.gpt_temperature,
-                model=self.gpt_model,
-                api_key=SecretStr(self.openai_api_key),
-            )
-        elif llm_ultimas_requests == "deepseek-chat":
-            llm = llm_instance.deepseek()
-        elif llm_ultimas_requests == "gemini-2.0-flash":
-            llm = llm_instance.google_gemini("gemini-2.0-flash")
-        elif llm_ultimas_requests == "gemini-2.5-pro":
-            llm = llm_instance.google_gemini("gemini-2.5-pro-preview-05-06")
-        elif llm_ultimas_requests == "gemini-2.5-flash":
-            llm = llm_instance.google_gemini("gemini-2.5-flash-preview-04-17")
-        return llm
-
-    async def gerar_documento_final(
+    async def do_last_requests(
         self,
-        vector_store: Chroma,
-        bm25: BM25Okapi,
-        chunk_ids: List[str],
-        llm_ultimas_requests: str,
-        query: str = "Summarize the main points of this document",
     ) -> List[Dict]:
         try:
+            self.axiom_instance.send_axiom("COMEÇANDO A FAZER ÚLTIMA REQUISIÇÃO")
+            vector_store, bm25, chunk_ids = self.enhanced_vector_store
+
             sources, contexts = self.rank_fusion_get_top_results(
-                vector_store, bm25, chunk_ids, query
+                vector_store,
+                bm25,
+                chunk_ids,
+                self.query_gerado_dinamicamente_para_o_vector_store,
             )
 
             prompt_gerar_documento = PromptTemplate(
@@ -249,14 +411,16 @@ class GerarDocumento:
                 input_variables=["context"],
             )
 
-            llm = self.select_model_for_last_requests(llm_ultimas_requests)  # type: ignore
+            llm_ultimas_requests = self.llm_ultimas_requests
             prompt_instance = Prompt()
             context_do_prompt_primeira_etapa = "\n\n".join(contexts)
             prompt_primeira_etapa = prompt_gerar_documento.format(
                 context=context_do_prompt_primeira_etapa,
             )
 
-            documento_gerado = await self.checar_se_resposta_vazia_do_documento_final(
+            self.gerar_documento_utils.model = self.gpt_model
+            self.gerar_documento_utils.temperature = self.llm_temperature
+            documento_gerado = await self.gerar_documento_utils.checar_se_resposta_vazia_do_documento_final(
                 llm_ultimas_requests, prompt_primeira_etapa
             )
 
@@ -274,7 +438,7 @@ class GerarDocumento:
                     dynamic_dict={"context": context_do_prompt_primeira_etapa},
                 )
                 # documento_gerado = llm.invoke(prompt_etapa_2).content
-                documento_gerado = self.checar_se_resposta_vazia_do_documento_final(
+                documento_gerado = self.gerar_documento_utils.checar_se_resposta_vazia_do_documento_final(
                     llm_ultimas_requests, prompt_etapa_2.to_string()
                 )
                 resposta_segunda_etapa = documento_gerado
@@ -292,7 +456,7 @@ class GerarDocumento:
                     },
                 )
                 # documento_gerado = llm.invoke(prompt_etapa_3).content
-                documento_gerado = self.checar_se_resposta_vazia_do_documento_final(
+                documento_gerado = self.gerar_documento_utils.checar_se_resposta_vazia_do_documento_final(
                     llm_ultimas_requests, prompt_etapa_3.to_string()
                 )
                 texto_final_juntando_as_etapas += f"\n\n{documento_gerado}"
@@ -306,49 +470,57 @@ class GerarDocumento:
             structured_output = self.gerar_documento_utils.criar_output_estruturado(
                 summaries, sources
             )
+
+            self.axiom_instance.send_axiom("TERMINOU DE FAZER A ÚLTIMA REQUISIÇÃO")
+            self.structured_output = structured_output
             return structured_output
 
         except Exception as e:
             self.logger.error(f"Error generating enhanced summary: {str(e)}")
             raise
 
-    async def checar_se_resposta_vazia_do_documento_final(
-        self, llm_ultimas_requests: str, prompt: str
-    ):
-        llm = self.select_model_for_last_requests(llm_ultimas_requests)  # type: ignore
-        documento_gerado = ""
-        tentativas = 0
+    async def generate_complete_text(self):
+        texto_completo = "\n\n"
 
-        while tentativas < 5 and not documento_gerado:
-            tentativas += 1
-            try:
-                resposta = llm.invoke(prompt)
-                if hasattr(resposta, "content") and resposta.content.strip():  # type: ignore
-                    if isinstance(resposta.content, list):
-                        resposta.content = "\n".join(resposta.content)  # type: ignore
+        for x in self.structured_output:
+            texto_completo = texto_completo + x["content"] + "\n"
+            x["source"]["text"] = x["source"]["text"][0:200]
+            x["source"]["context"] = x["source"]["context"][0:200]
 
-                    documento_gerado = resposta.content.strip()  # type: ignore
-                else:
-                    print(f"Tentativa {tentativas}: resposta vazia ou inexistente.")
-            except Exception as e:
-                llm = self.select_model_for_last_requests("gemini-2.0-flash")
-                print(f"Tentativa {tentativas}: erro ao invocar o modelo: {e}")
-            time.sleep(5)
+        self.texto_completo_como_html = convert_markdown_to_HTML(
+            texto_completo
+        ).replace("resposta_segunda_etapa:", "<br><br>")
 
-        if not documento_gerado:
-            try:
-                self.axiom_instance.send_axiom(
-                    "TENTANDO GERAR DOCUMENTO FINAL COM GPT 4o-mini COMO ÚLTIMA TENTATIVA"
-                )
-                documento_gerado = (
-                    self.gerar_documento_utils.ultima_tentativa_requisicao(prompt)
-                )
-            except Exception as e:
-                raise Exception(
-                    "Falha ao gerar o documento final na última tentativa."
-                ) from e
+        self.axiom_instance.send_axiom(
+            f"texto_completo_como_html: {self.texto_completo_como_html}"
+        )
 
-        return documento_gerado
+    async def get_document_title(self):
+        if self.is_contextualized_chunk:
+            resumo_para_gerar_titulo = self.resumo_auxiliar
+        else:
+            resumo_para_gerar_titulo = self.texto_completo_como_html
+
+        prompt = prompt_para_gerar_titulo(resumo_para_gerar_titulo)
+        response = await agemini_answer(
+            prompt, "gemini-2.0-flash-lite", temperature=self.llm_temperature
+        )
+        self.titulo_do_documento = response
+        return self.titulo_do_documento
+
+    async def send_to_bubble(self):
+        self.axiom_instance.send_axiom("COMEÇANDO A REQUISIÇÃO FINAL PARA O BUBBLE")
+
+        enviar_resposta_final(
+            self.serializer.doc_id,  # type: ignore
+            self.serializer.form_response_id,  # type: ignore
+            self.serializer.version,  # type: ignore
+            self.texto_completo_como_html,
+            False,
+            cast(str, self.titulo_do_documento),
+        )
+
+        self.axiom_instance.send_axiom("TERMINOU A REQUISIÇÃO FINAL PARA O BUBBLE")
 
     async def gerar_ementa_final(
         self,
@@ -357,10 +529,10 @@ class GerarDocumento:
         context_primeiro_prompt: str,
     ):
 
-        llm = self.select_model_for_last_requests(llm_ultimas_requests)  # type: ignore
+        llm = self.gerar_documento_utils.select_model_for_last_requests(llm_ultimas_requests)  # type: ignore
         prompt_instance = Prompt()
 
-        documento_gerado = await self.checar_se_resposta_vazia_do_documento_final(
+        documento_gerado = await self.gerar_documento_utils.checar_se_resposta_vazia_do_documento_final(
             llm_ultimas_requests, prompt_primeira_etapa
         )
 
@@ -395,3 +567,77 @@ class GerarDocumento:
             self.axiom_instance.send_axiom(f"RESULTADO ETAPA 3: {documento_gerado}")
 
         return texto_final_juntando_as_etapas
+
+    # Esta função gera a resposta que será usada em cada um das requisições de cada chunk
+    async def get_response_from_auxiliar_contextual_prompt(self):
+        llms = LLM()
+        responses = []
+
+        current_chunk = []
+        current_token_count = 0
+        chunk_counter = 1
+
+        for part in self.full_text_as_array:
+            part_tokens = len(self.encoding_tiktoken.encode(part))
+
+            # Check if adding this part would EXCEED the limit
+            if current_token_count + part_tokens > 600000:
+                # Process the accumulated chunk before it exceeds the limit
+                chunk_text = "".join(current_chunk)
+                print(
+                    f"\nProcessing chunk {chunk_counter} with {current_token_count} tokens"
+                )
+
+                prompt = create_prompt_auxiliar_do_contextual_prompt(chunk_text)
+                response = await llms.google_gemini(
+                    temperature=self.llm_temperature
+                ).ainvoke([HumanMessage(content=prompt)])
+                responses.append(response.content)
+
+                # Start new chunk with current part
+                current_chunk = [part]
+                current_token_count = part_tokens
+                chunk_counter += 1
+            else:
+                # Safe to add to current chunk
+                current_chunk.append(part)
+                current_token_count += part_tokens
+
+        # Process the final remaining chunk
+        if current_chunk:
+            chunk_text = "".join(current_chunk)
+            print(
+                f"\nProcessing final chunk {chunk_counter} with {current_token_count} tokens"
+            )
+            prompt = create_prompt_auxiliar_do_contextual_prompt(chunk_text)
+            response = await llms.google_gemini(
+                temperature=self.llm_temperature
+            ).ainvoke([HumanMessage(content=prompt)])
+            responses.append(response.content)
+
+        self.resumo_auxiliar = "".join(responses)
+        self.ax.resumo_inicial_processo(self.resumo_auxiliar)
+
+        return self.resumo_auxiliar
+
+    def gerar_resposta_compilada(self):
+        serializer = self.serializer
+        return {
+            "num_chunks_retrieval": serializer.num_chunks_retrieval,
+            "embedding_weight": serializer.embedding_weight,
+            "bm25_weight": serializer.bm25_weight,
+            "context_window": serializer.context_window,
+            "chunk_overlap": serializer.chunk_overlap,
+            "num_k_rerank": serializer.num_k_rerank,
+            "model_cohere_rerank": serializer.model_cohere_rerank,
+            "more_initial_chunks_for_reranking": serializer.more_initial_chunks_for_reranking,
+            "claude_context_model": serializer.claude_context_model,
+            "gpt_temperature": serializer.gpt_temperature,
+            "user_message": serializer.user_message,
+            "model": serializer.model,
+            "hf_embedding": serializer.hf_embedding,
+            "chunk_size": serializer.chunk_size,
+            "chunk_overlap": serializer.chunk_overlap,
+            # "prompt_auxiliar": serializer.prompt_auxiliar,
+            "prompt_gerar_documento": serializer.prompt_gerar_documento[0:200],
+        }

_utils/gerar_documento_utils/llm_calls.py

@@ -62,8 +62,9 @@ async def agemini_answer(
     model: Literal[
         "gemini-2.5-pro-preview-05-06", "gemini-2.0-flash", "gemini-2.0-flash-lite"
     ] = "gemini-2.0-flash",
+    temperature=0.4,
 ) -> str:
-    gemini = llm.google_gemini(model)
+    gemini = llm.google_gemini(model, temperature)
     resposta = await gemini.ainvoke([HumanMessage(content=prompt)])
 
     if isinstance(resposta.content, list):

_utils/gerar_documento_utils/prompts.py

@@ -1,4 +1,14 @@
-def create_prompt_auxiliar_do_contextual_prompt(PROCESSO_JURIDICO: str):
+def create_prompt_auxiliar_do_contextual_prompt(PROCESSO_JURIDICO: str | None = None):
+    if PROCESSO_JURIDICO:
+        adicionar_ao_prompt = f"""
+1.  **Análise Completa:** Leia e analise todo o conteúdo do processo fornecido.
+<processo_juridico>
+{PROCESSO_JURIDICO}
+</processo_juridico>"""
+    else:
+        adicionar_ao_prompt = """
+1.  **Análise Completa:** Leia e analise todo o conteúdo do processo fornecido como PDF."""
+
     return f"""
 <prompt>
 <persona>
@@ -46,10 +56,7 @@ Seu objetivo é analisar o processo jurídico fornecido e gerar um relatório co
 <instrucoes>
 Siga estritamente os passos abaixo:
 
-1.  **Análise Completa:** Leia e analise todo o conteúdo do processo fornecido.
-    <processo_juridico>
-    {PROCESSO_JURIDICO}
-    </processo_juridico>
+{adicionar_ao_prompt}
 
 2.  **Identificação e Listagem de Peças:** Identifique quais das peças listadas na `<tarefa>` estão presentes no texto. Liste **apenas** as encontradas na tag `<pecas_identificadas>`.
 
@@ -239,3 +246,7 @@ def prompt_gerar_query_dinamicamente(resumo_do_processo: str):
 
 - *Importante:** Sua resposta final deve ser *somente* a string da query.
 """
+
+
+def prompt_para_gerar_titulo(resumo_para_gerar_titulo: str):
+    return f"Você é um assistente jurídico e irá receber abaixo o resumo de um documento jurídico. Quero que você gere um título para este documento. Mande como resposta apenas o título gerado, nada mais. Aqui está um título de exemplo pra você se basear ao criar um novo: <titulo_de_exemplo>Ação Penal por Furto Qualificado nº 0002269-86.2009.805.0032<titulo_de_exemplo>\n\nSegue abaixo o resumo do documento jurídico:\n{resumo_para_gerar_titulo}"

_utils/gerar_documento_utils/utils.py

@@ -1,91 +1,10 @@
-from typing import Any, List, Tuple, Union
-from langchain_core.documents import Document
-from langchain_core.messages import HumanMessage
-
 from _utils.gerar_documento_utils.llm_calls import agemini_answer
-from _utils.langchain_utils.Splitter_class import Splitter
-from _utils.langchain_utils.LLM_class import LLM
-from _utils.gerar_documento_utils.prompts import (
-    create_prompt_auxiliar_do_contextual_prompt,
-)
-
-from _utils.models.gerar_documento import DocumentChunk
-from gerar_documento.serializer import GerarDocumentoSerializerData
+from _utils.gerar_documento_utils.prompts import prompt_para_gerar_titulo
 import tiktoken
 
 encoding = tiktoken.get_encoding("cl100k_base")
 
 
-def gerar_resposta_compilada(serializer: Union[GerarDocumentoSerializerData, Any]):
-    return {
-        "num_chunks_retrieval": serializer.num_chunks_retrieval,
-        "embedding_weight": serializer.embedding_weight,
-        "bm25_weight": serializer.bm25_weight,
-        "context_window": serializer.context_window,
-        "chunk_overlap": serializer.chunk_overlap,
-        "num_k_rerank": serializer.num_k_rerank,
-        "model_cohere_rerank": serializer.model_cohere_rerank,
-        "more_initial_chunks_for_reranking": serializer.more_initial_chunks_for_reranking,
-        "claude_context_model": serializer.claude_context_model,
-        "gpt_temperature": serializer.gpt_temperature,
-        "user_message": serializer.user_message,
-        "model": serializer.model,
-        "hf_embedding": serializer.hf_embedding,
-        "chunk_size": serializer.chunk_size,
-        "chunk_overlap": serializer.chunk_overlap,
-        # "prompt_auxiliar": serializer.prompt_auxiliar,
-        "prompt_gerar_documento": serializer.prompt_gerar_documento[0:200],
-    }
-
-
-# Esta função gera a resposta que será usada em cada um das requisições de cada chunk
-async def get_response_from_auxiliar_contextual_prompt(full_text_as_array: List[str]):
-    llms = LLM()
-    responses = []
-
-    current_chunk = []
-    current_token_count = 0
-    chunk_counter = 1
-
-    for part in full_text_as_array:
-        part_tokens = len(encoding.encode(part))
-
-        # Check if adding this part would EXCEED the limit
-        if current_token_count + part_tokens > 600000:
-            # Process the accumulated chunk before it exceeds the limit
-            chunk_text = "".join(current_chunk)
-            print(
-                f"\nProcessing chunk {chunk_counter} with {current_token_count} tokens"
-            )
-
-            prompt = create_prompt_auxiliar_do_contextual_prompt(chunk_text)
-            response = await llms.google_gemini().ainvoke(
-                [HumanMessage(content=prompt)]
-            )
-            responses.append(response.content)
-
-            # Start new chunk with current part
-            current_chunk = [part]
-            current_token_count = part_tokens
-            chunk_counter += 1
-        else:
-            # Safe to add to current chunk
-            current_chunk.append(part)
-            current_token_count += part_tokens
-
-    # Process the final remaining chunk
-    if current_chunk:
-        chunk_text = "".join(current_chunk)
-        print(
-            f"\nProcessing final chunk {chunk_counter} with {current_token_count} tokens"
-        )
-        prompt = create_prompt_auxiliar_do_contextual_prompt(chunk_text)
-        response = await llms.google_gemini().ainvoke([HumanMessage(content=prompt)])
-        responses.append(response.content)
-
-    return "".join(responses)
-
-
 def split_text_by_tokens(full_text: str):
     tokens = encoding.encode(full_text)
     max_tokens = 600000
@@ -101,27 +20,7 @@ def split_text_by_tokens(full_text: str):
     return text_chunks
 
 
-async def get_full_text_and_all_PDFs_chunks(
-    listaPDFs: List[str],
-    splitterObject: Splitter,
-    should_use_llama_parse: bool,
-    isBubble: bool,
-) -> Tuple[List[DocumentChunk], List[str]]:
-    all_PDFs_chunks: List[DocumentChunk] = []
-
-    pages: List[str] = []
-
-    # Load and process document
-    for pdf_path in listaPDFs:
-        chunks, pages = await splitterObject.load_and_split_document(
-            pdf_path, should_use_llama_parse, isBubble
-        )
-        all_PDFs_chunks = all_PDFs_chunks + chunks
-
-    return all_PDFs_chunks, pages
-
-
 async def generate_document_title(resumo_para_gerar_titulo: str):
-    prompt = f"Você é um assistente jurídico e irá receber abaixo o resumo de um documento jurídico. Quero que você gere um título para este documento. Mande como resposta apenas o título gerado, nada mais. Aqui está um título de exemplo pra você se basear ao criar um novo: <titulo_de_exemplo>Ação Penal por Furto Qualificado nº 0002269-86.2009.805.0032<titulo_de_exemplo>\n\nSegue abaixo o resumo do documento jurídico:\n{resumo_para_gerar_titulo}"
+    prompt = prompt_para_gerar_titulo(resumo_para_gerar_titulo)
     response = await agemini_answer(prompt, "gemini-2.0-flash-lite")
     return response

_utils/google_integration/google_cloud.py

@@ -0,0 +1,28 @@
+import os
+from google.cloud import storage
+
+GCP_PROJECT = "gen-lang-client-0350149082"
+GCP_REGION = "us-central1"
+DOCUMENT_API_ID = "b34a20d22dee16bb"
+GCS_BUCKET_NAME = "vella-pdfs"
+
+
+def upload_to_gcs(LOCAL_PDF_PATH: str) -> str:
+
+    # Path in GCS
+    GCS_DESTINATION_BLOB_NAME = "gemini_uploads/" + os.path.basename(LOCAL_PDF_PATH)
+
+    """Uploads a file to a GCS bucket and returns its URI."""
+    storage_client = storage.Client(
+        project=GCP_PROJECT,
+    )
+    bucket = storage_client.bucket(GCS_BUCKET_NAME)
+    blob = bucket.blob(GCS_DESTINATION_BLOB_NAME)
+
+    print(
+        f"Uploading {LOCAL_PDF_PATH} to gs://{GCS_BUCKET_NAME}/{GCS_DESTINATION_BLOB_NAME}..."
+    )
+    blob.upload_from_filename(LOCAL_PDF_PATH)
+    gcs_uri = f"gs://{GCS_BUCKET_NAME}/{GCS_DESTINATION_BLOB_NAME}"
+    print(f"File uploaded to {gcs_uri}")
+    return gcs_uri

_utils/langchain_utils/LLM_class.py

@@ -1,9 +1,10 @@
-from typing import Literal, cast
+from typing import List, Literal, cast
 from pydantic import SecretStr
-from setup.environment import default_model
+from _utils.google_integration.google_cloud import GCP_PROJECT, upload_to_gcs
 from setup.easy_imports import ChatOpenAI, ChatGoogleGenerativeAI
 import os
 from langchain_core.messages import HumanMessage
+from langchain_google_vertexai import ChatVertexAI
 
 deepseek_api_key = cast(str, os.environ.get("DEEPSEEKK_API_KEY"))
 google_api_key = cast(str, os.environ.get("GOOGLE_API_KEY_PEIXE"))
@@ -31,14 +32,11 @@ class LLM:
             model=model,
         )
 
-    def google_gemini(
-        self,
-        model: Google_llms = "gemini-2.0-flash",
-    ):
+    def google_gemini(self, model: Google_llms = "gemini-2.0-flash", temperature=0.4):
         return ChatGoogleGenerativeAI(
             api_key=SecretStr(google_api_key),
             model=model,
-            temperature=0.4,
+            temperature=temperature,
             max_tokens=None,
             timeout=None,
             max_retries=2,
@@ -49,10 +47,11 @@ class LLM:
         prompt: str,
         model: Google_llms = "gemini-2.0-flash",
         max_retries: int = 3,
+        temperature=0.4,
     ):
         for attempt in range(max_retries):
             try:
-                response = await self.google_gemini(model).ainvoke(
+                response = await self.google_gemini(model, temperature).ainvoke(
                     [HumanMessage(content=prompt)]
                 )
 
@@ -75,3 +74,44 @@ class LLM:
             raise Exception(
                 "Failed to generate the final document after 5 retries and the fallback attempt with chat-gpt-4o-mini."
             ) from e
+
+    async def google_gemini_vertex_ainvoke(
+        self,
+        prompt: str,
+        list_of_pdfs: List[str],
+        model: Google_llms = "gemini-2.5-flash-preview-04-17",
+        max_retries: int = 3,
+    ) -> str | None:
+        message_parts = [
+            {"type": "text", "text": prompt},
+        ]
+        for pdf in list_of_pdfs:
+            pdf_gcs_uri = upload_to_gcs(pdf)
+            message_parts.append(
+                {
+                    # This structure is used for file references via URI
+                    "type": "media",
+                    "mime_type": "application/pdf",  # <-- mime_type moved up
+                    "file_uri": pdf_gcs_uri,  # <-- file_uri moved up
+                }
+            )
+
+        for attempt in range(max_retries):
+            try:
+                llm = ChatVertexAI(
+                    model_name=model,
+                    project=GCP_PROJECT,
+                    location="us-central1",
+                    temperature=0,
+                )
+                response = await llm.ainvoke(
+                    [HumanMessage(content=message_parts)]  # type: ignore
+                )
+
+                if isinstance(response.content, list):
+                    response.content = "\n".join(response.content)  # type: ignore
+
+                return response.content  # type: ignore
+            except Exception as e:
+                model = "gemini-2.0-flash"
+                print(f"Attempt {attempt + 1} failed with error: {e}")

_utils/langchain_utils/Splitter_class.py

@@ -1,4 +1,9 @@
-from _utils.bubble_integrations.obter_arquivo import get_pdf_from_bubble
+import os
+import time
+from _utils.bubble_integrations.obter_arquivo import (
+    download_file_from_bubble,
+    get_pdf_from_bubble,
+)
 from _utils.handle_files import return_document_list_with_llama_parser
 from _utils.langchain_utils.splitter_util import (
     Splitter_Simple,
@@ -18,6 +23,17 @@ from _utils.models.gerar_documento import (
     DocumentChunk,
 )
 import uuid
+import json
+from _utils.google_integration.google_cloud import (
+    DOCUMENT_API_ID,
+    GCP_PROJECT,
+    GCP_REGION,
+    GCS_BUCKET_NAME,
+    upload_to_gcs,
+)
+from google.cloud import documentai
+from google.cloud import storage
+from _utils.bubble_integrations.obter_arquivo import headers
 
 
 class Splitter:
@@ -34,7 +50,10 @@ class Splitter:
         self.chunk_metadata = {}  # Store chunk metadata for tracing
 
     async def load_and_split_document(
-        self, pdf_path: str, should_use_llama_parse: bool, isBubble: bool
+        self,
+        pdf_path: str,
+        should_use_llama_parse: bool,
+        isBubble: bool,
     ):
         """Load PDF and split into chunks with metadata"""
         # loader = PyPDFLoader(pdf_path)
@@ -144,6 +163,13 @@ class Splitter:
             # char_count += len(text)
         print("TERMINOU DE ORGANIZAR PDFS EM CHUNKS")
 
+        if len(pages) == 0 or len(chunks) == 0:
+            if isBubble:
+                pdf_path = download_file_from_bubble(pdf_path, headers, "pdf")
+            text = await self.getOCRFromGoogleDocumentAPI(pdf_path)
+            chunks = self.load_and_split_text(text)  # type: ignore
+            chunks_of_string_only = [chunk.content for chunk in chunks]
+
         return chunks, chunks_of_string_only
 
     def load_and_split_text(self, text: str) -> List[DocumentChunk]:
@@ -185,3 +211,132 @@ class Splitter:
         char_count += len(text)
 
         return chunks
+
+    async def getOCRFromGoogleDocumentAPI(self, pdf_path: str):
+
+        pdf_gcs_uri = upload_to_gcs(pdf_path)
+
+        GCS_OUTPUT_PREFIX = "documentai_output/"
+        # GCS_INPUT_URI = f"gs://{GCS_BUCKET_NAME}/{f"gemini_uploads/{pdf_gcs_uri}"}"
+        GCS_INPUT_URI = pdf_gcs_uri
+        GCS_OUTPUT_URI = f"gs://{GCS_BUCKET_NAME}/{GCS_OUTPUT_PREFIX}"
+
+        docai_client = documentai.DocumentProcessorServiceClient()
+
+        processor_name = docai_client.processor_path(
+            project=GCP_PROJECT, location="us", processor=DOCUMENT_API_ID
+        )
+
+        gcs_document = documentai.GcsDocument(
+            gcs_uri=GCS_INPUT_URI,
+            mime_type="application/pdf",  # Mime type is specified here for GcsDocument
+        )
+
+        gcs_documents = documentai.GcsDocuments(documents=[gcs_document])
+
+        # 3. Create the BatchDocumentsInputConfig
+        input_config = documentai.BatchDocumentsInputConfig(gcs_documents=gcs_documents)
+        # Note: If GCS_INPUT_URI was a prefix for multiple files, you'd use GcsPrefix:
+        # gcs_prefix = documentai.GcsPrefix(gcs_uri_prefix=GCS_INPUT_URI_PREFIX)
+        # input_config = documentai.BatchDocumentsInputConfig(gcs_prefix=gcs_prefix, mime_type="application/pdf")
+
+        # 4. Create the DocumentOutputConfig
+        # GCS_OUTPUT_URI should be a gs:// URI prefix where the output JSONs will be stored
+        output_config = documentai.DocumentOutputConfig(
+            gcs_output_config=documentai.DocumentOutputConfig.GcsOutputConfig(
+                gcs_uri=GCS_OUTPUT_URI
+            )
+        )
+
+        # 5. Construct the BatchProcessRequest
+        request = documentai.BatchProcessRequest(
+            name=processor_name,
+            input_documents=input_config,  # Use 'input_documents'
+            document_output_config=output_config,  # Use 'document_output_config'
+        )
+
+        # Submit the batch process request (this is a long-running operation)
+        operation = docai_client.batch_process_documents(request)
+
+        print("Batch processing operation started. Waiting for completion...")
+        while not operation.done():
+            time.sleep(15)  # Wait for 30 seconds before checking again
+            print("Waiting...")
+
+        print("Batch processing operation finished.")
+
+        # --- Download the results from GCS ---
+        storage_client = storage.Client(
+            project=GCP_PROJECT
+        )  # Uses GOOGLE_APPLICATION_CREDENTIALS/ADC
+        bucket = storage_client.bucket(GCS_BUCKET_NAME)
+
+        output_blobs = storage_client.list_blobs(
+            GCS_BUCKET_NAME, prefix=GCS_OUTPUT_PREFIX
+        )
+
+        downloaded_files_texts = []
+        try:
+            for blob in output_blobs:
+                # Document AI adds suffixes and subdirectories. Look for the actual JSON output files.
+                # The exact naming depends on the processor and options. Common pattern is ending with .json
+                if blob.name.endswith(".json"):
+                    local_download_path = os.path.basename(
+                        blob.name
+                    )  # Download to current directory with blob name
+                    print(f"Downloading {blob.name} to {local_download_path}...")
+                    blob.download_to_filename(local_download_path)
+
+                    with open(local_download_path, "r", encoding="utf-8") as f:
+                        document_data = json.load(f)
+
+                    # The top-level 'text' field contains the concatenated plain text.
+                    if "text" in document_data and document_data["text"] is not None:
+                        raw_text = document_data["text"]
+                        print(f"\n--- Raw Text Extracted from {blob.name} ---")
+                        # Print only a snippet or process as needed
+                        print(
+                            raw_text[:1000] + "..."
+                            if len(raw_text) > 1000
+                            else raw_text
+                        )
+                        print("--------------------------------------------")
+
+                        return raw_text
+
+                        # Optional: Store the text. If you processed a batch of files,
+                        # you might want to associate the text with the original file name.
+                        # Document AI metadata might link output JSONs back to input files.
+                        # For simplicity here, let's just show the extraction.
+                        # If you know it was a single input PDF, this is all the text.
+                        # If it was multiple, you'd need a mapping or process each JSON.
+
+                    else:
+                        print(
+                            f"Warning: 'text' field not found in {blob.name} or is empty."
+                        )
+
+                    # Optional: Read and print a snippet of the JSON content
+                    # with open(local_download_path, 'r', encoding='utf-8') as f:
+                    #     data = json.load(f)
+                    #     # Print some extracted text, for example (structure varies by processor)
+                    #     if 'text' in data:
+                    #         print(f"Extracted text snippet: {data['text'][:500]}...") # Print first 500 chars
+                    #     elif 'entities' in data:
+                    #         print(f"Number of entities found: {len(data['entities'])}")
+                    #     else:
+                    #         print("Output JSON structure not immediately recognizable.")
+                    # break # Uncomment if you only expect/need to process the first output file
+
+            if len(downloaded_files_texts) == 0 or not downloaded_files_texts:
+                print("No JSON output files found in the specified output location.")
+
+        except Exception as e:
+            print(f"Error listing or downloading output files: {e}")
+
+        print("\nProcess complete.")
+        if downloaded_files_texts:
+            print(f"Downloaded output file(s): {', '.join(downloaded_files_texts)}")
+            print("These files contain the OCR results in JSON format.")
+        else:
+            print("No output files were successfully downloaded.")

_utils/langchain_utils/Vector_store_class.py

@@ -22,6 +22,8 @@ class VectorStore:
         axiom_instance: Axiom,
     ) -> Tuple[Chroma, BM25Okapi, List[str]]:
         """Create vector store and BM25 index with contextualized chunks"""
+        contador_erro = 0
+
         try:
             # Prepare texts with context
             if is_contextualized_chunk:
@@ -69,5 +71,9 @@ class VectorStore:
             return vector_store, bm25, chunk_ids
 
         except Exception as e:
+            contador_erro += 1
+            if contador_erro >= 2:
+                raise Exception(f"Error creating enhanced vector store: {str(e)}")
+
             self.logger.error(f"Error creating enhanced vector store: {str(e)}")
-            raise Exception(f"Error creating enhanced vector store: {str(e)}")
+            return self.create_enhanced_vector_store(chunks, False, axiom_instance)

_utils/ragas.py

@@ -76,7 +76,7 @@ def test_ragas(serializer, listaPDFs):
 
     def generate_summary(vector_store, bm25, chunk_ids, query, summarizer):
         """Generates an enhanced summary using the vector store and BM25 index."""
-        structured_summaries = summarizer.gerar_documento_final(
+        structured_summaries = summarizer.do_last_requests(
             vector_store, bm25, chunk_ids, query
         )
         return {"structured_summaries": structured_summaries}

entrypoint.sh

@@ -0,0 +1,26 @@
+#!/bin/sh
+set -e # Exit immediately if a command exits with a non-zero status.
+
+CREDENTIALS_FILE_PATH="/app/vella_gcp_luan_credentials.json"
+
+# Check if the GCP_CREDENTIALS_JSON_CONTENT secret is provided
+if [ -n "$GCP_CREDENTIALS_JSON_CONTENT" ]; then
+  echo "GCP_CREDENTIALS_JSON_CONTENT secret found. Writing to $CREDENTIALS_FILE_PATH"
+  # Use printf to preserve newlines and special characters correctly
+  printf "%s" "$GCP_CREDENTIALS_JSON_CONTENT" > "$CREDENTIALS_FILE_PATH"
+  export GOOGLE_APPLICATION_CREDENTIALS="$CREDENTIALS_FILE_PATH"
+  echo "GOOGLE_APPLICATION_CREDENTIALS set to $CREDENTIALS_FILE_PATH"
+
+  # Optional: Add a check to see if the file looks like JSON (basic check)
+  if command -v jq >/dev/null && jq -e . "$CREDENTIALS_FILE_PATH" >/dev/null 2>&1; then
+    echo "Credentials file appears to be valid JSON."
+  else
+    echo "Warning: Credentials file may not be valid JSON. Content:"
+    # cat "$CREDENTIALS_FILE_PATH" # Print the content for debugging
+  fi
+
+else
+  echo "Warning: GCP_CREDENTIALS_JSON_CONTENT secret not found. GCP services might not authenticate."
+fi
+
+exec "$@"

gerar_documento/serializer.py

@@ -73,7 +73,7 @@ class FileInfoSerializerData:
 class GerarDocumentoSerializer(
     GerarDocumentoInitialSerializer, GerarDocumentoParametros
 ):
-    files = serializers.ListField(child=FileInfoSerializer(), required=True)
+    files = serializers.CharField(required=True)
     bubble_editor_version = serializers.CharField(
         required=False, default="version-test"
     )  # Será o valor utilizado dentro da URL da requisição pro Bubble
@@ -89,7 +89,7 @@ class GerarDocumentoSerializer(
 class GerarDocumentoSerializerData(
     GerarDocumentoParametrosData, GerarDocumentoInitialSerializerData
 ):
-    files: List[FileInfoSerializerData]
+    files: str
     bubble_editor_version: str = "version-test"
 
     doc_id: str = ""
@@ -100,6 +100,8 @@ class GerarDocumentoSerializerData(
 class GerarDocumentoComPDFProprioSerializer(
     GerarDocumentoInitialSerializer, GerarDocumentoParametros
 ):
+    files = serializers.ListField(required=True)
+
     def get_obj(self):
         return GerarDocumentoSerializerData(**self.validated_data)  # type: ignore
 
@@ -108,17 +110,4 @@ class GerarDocumentoComPDFProprioSerializer(
 class GerarDocumentoComPDFProprioSerializerData(
     GerarDocumentoParametrosData, GerarDocumentoInitialSerializerData
 ):
-    pass
-
-
-class GerarEmentaSerializer(serializers.Serializer):
-    files = serializers.ListField(child=FileInfoSerializer(), required=True)
-    user_message = serializers.CharField(required=False, default="")
-    chunk_size = serializers.IntegerField(required=False, default=3500)
-    chunk_overlap = serializers.IntegerField(required=False, default=800)
-    bubble_editor_version = serializers.CharField(
-        required=False, default="version-test"
-    )  # Será o valor utilizado dentro da URL da requisição pro Bubble
-    doc_id = serializers.CharField(required=True)
-    form_response_id = serializers.CharField(required=True)
-    version = serializers.CharField(required=True)
+    files: List[FileInfoSerializerData]

gerar_documento/views.py

@@ -1,13 +1,12 @@
 from typing import Any, Dict, cast
 from langchain.prompts import PromptTemplate
+from _utils.Utils_Class import UtilsClass
 from _utils.bubble_integrations.enviar_resposta_final import enviar_resposta_final
-from _utils.custom_exception_handler import custom_exception_handler_wihout_api_handler
+from _utils.custom_exception_handler import custom_exception_handler_without_api_handler
 from _utils.gerar_documento_utils.GerarDocumento import GerarDocumento
 from _utils.langchain_utils.LLM_class import LLM
 from _utils.gerar_documento_utils.utils import (
     generate_document_title,
-    gerar_resposta_compilada,
-    get_full_text_and_all_PDFs_chunks,
     split_text_by_tokens,
 )
 from _utils.langchain_utils.Prompt_class import Prompt
@@ -29,10 +28,10 @@ from setup.logging import Axiom, send_axiom
 from .serializer import (
     GerarDocumentoComPDFProprioSerializer,
     GerarDocumentoSerializer,
-    GerarEmentaSerializer,
 )
 import asyncio
 from _utils.langchain_utils.Splitter_class import Splitter
+import json
 
 
 class GerarDocumentoView(AsyncAPIView):
@@ -60,7 +59,8 @@ class GerarDocumentoView(AsyncAPIView):
                 data = cast(Dict[str, Any], serializer.validated_data)
                 self.serializer = data
 
-                listaPDFs = [l["link_arquivo"] for l in data["files"]]
+                listaPDFs = json.loads(obj.files)
+                listaPDFs = [l["link_arquivo"] for l in listaPDFs]
 
                 self.axiom_instance.send_axiom(f"listaPDFs: {listaPDFs}")
 
@@ -138,17 +138,23 @@ class GerarEmentaView(AsyncAPIView):
 
             async def proccess_data_after_response():
                 try:
+                    util = UtilsClass()
+                    handle_files = util.handle_files
                     data = cast(Dict[str, Any], serializer.validated_data)
                     self.serializer = data
 
-                    gerar_documento_instance = GerarDocumento(obj, self.axiom_instance)
+                    gerar_documento_instance = GerarDocumento(
+                        obj, True, self.axiom_instance
+                    )
 
-                    listaPDFs = [l["link_arquivo"] for l in data["files"]]
+                    # listaPDFs = [l["link_arquivo"] for l in data["files"]]
+                    listaPDFs = json.loads(obj.files)
+                    listaPDFs = [l["link_arquivo"] for l in listaPDFs]
 
                     self.axiom_instance.send_axiom(f"listaPDFs: {listaPDFs}")
 
                     all_PDFs_chunks, full_text_as_array = (
-                        await get_full_text_and_all_PDFs_chunks(
+                        await handle_files.get_full_text_and_all_PDFs_chunks(
                             listaPDFs,
                             Splitter(obj.chunk_size, obj.chunk_overlap),
                             False,
@@ -208,7 +214,7 @@ class GerarEmentaView(AsyncAPIView):
                     )
                 except Exception as e:
                     print(f"ERRO GERAR EMENTA: {e}")
-                    custom_exception_handler_wihout_api_handler(
+                    custom_exception_handler_without_api_handler(
                         e, serializer, self.axiom_instance
                     )
                     raise
@@ -239,6 +245,8 @@ class GerarEmentaComPDFProprioView(AsyncAPIView):
             f"COMEÇOU NOVA REQUISIÇÃO - request.data: {request.data}"
         )
         serializer = GerarDocumentoComPDFProprioSerializer(data=request.data)
+        util = UtilsClass()
+        handle_files = util.handle_files
         if serializer.is_valid(raise_exception=True):
             data = cast(Dict[str, Any], serializer.validated_data)
             self.axiom_instance.send_axiom(f"data: {data}")
@@ -246,7 +254,7 @@ class GerarEmentaComPDFProprioView(AsyncAPIView):
             serializer_obj = serializer.get_obj()
 
             gerar_documento_instance = GerarDocumento(
-                serializer_obj, self.axiom_instance
+                serializer_obj, False, self.axiom_instance
             )
 
             listaPDFs = handle_pdf_files_from_serializer(
@@ -255,7 +263,7 @@ class GerarEmentaComPDFProprioView(AsyncAPIView):
             self.axiom_instance.send_axiom(f"listaPDFs: {listaPDFs}")
 
             all_PDFs_chunks, full_text_as_array = (
-                await get_full_text_and_all_PDFs_chunks(
+                await handle_files.get_full_text_and_all_PDFs_chunks(
                     listaPDFs,
                     Splitter(serializer_obj.chunk_size, serializer_obj.chunk_overlap),
                     False,

setup/installed_apps.py

@@ -16,4 +16,5 @@ INSTALLED_APPS = config_apps + [
     "modelos_usuarios",
     "ragas_api",
     "gerar_documento",
+    "simple_llm",
 ]

setup/urls.py

@@ -19,4 +19,5 @@ urlpatterns = config_urls + [
     path("", include("gerar_documento.urls")),
     path("", include("ragas_api.urls")),
     path("", include("modelos_usuarios.urls")),
+    path("", include("simple_llm.urls")),
 ]

simple_llm/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

simple_llm/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class SimpleLlmConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'simple_llm'

simple_llm/models.py

@@ -0,0 +1,3 @@
+from django.db import models
+
+# Create your models here.

simple_llm/serializer.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Union
+from rest_framework import serializers
+from _utils.gerar_documento_utils.prompts import (
+    prompt_gerar_documento,
+)
+from gerar_documento.serializer import FileInfoSerializer, FileInfoSerializerData
+from gerar_documento.serializer_base import (
+    GerarDocumentoParametros,
+    GerarDocumentoParametrosData,
+)
+from setup.environment import default_model
+from django.core.files.uploadedfile import UploadedFile
+
+user_message = "What are the main points of this document?"
+
+
+class SimpleLLMInitialSerializer(serializers.Serializer):
+    files = serializers.ListField(child=serializers.FileField(), required=False)
+    user_text = serializers.CharField(required=False, default=user_message)
+    model = serializers.CharField(required=False, default=default_model)
+    prompt = serializers.CharField(required=False, default=prompt_gerar_documento)
+    llm_ultimas_requests = serializers.CharField(
+        required=False, default="gemini-2.0-flash"
+    )
+
+
+@dataclass
+class SimpleLLMInitialSerializerData:
+    files: List[dict] = field(default_factory=list)
+    user_text: str = ""
+    model: str = default_model
+    prompt: str = ""
+    llm_ultimas_requests: str = "gemini-2.0-flash"
+
+
+class SimpleLLMSerializer(SimpleLLMInitialSerializer):
+    files = serializers.ListField(child=FileInfoSerializer(), required=False)
+    bubble_editor_version = serializers.CharField(
+        required=False, default="version-test"
+    )  # Será o valor utilizado dentro da URL da requisição pro Bubble
+    doc_id = serializers.CharField(required=True)
+    form_response_id = serializers.CharField(required=True)
+    version = serializers.CharField(required=True)
+
+    def get_obj(self):
+        return SimpleSerializerData(**self.validated_data)  # type: ignore
+
+
+@dataclass
+class SimpleSerializerData(SimpleLLMInitialSerializerData):
+    files: List[FileInfoSerializerData] = field(default_factory=list)
+    bubble_editor_version: str = "version-test"
+
+    doc_id: str = ""
+    form_response_id: str = ""
+    version: str = ""

simple_llm/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

simple_llm/urls.py

@@ -0,0 +1,11 @@
+from django.urls import path
+
+from simple_llm.views import SimpleLLMView
+
+urlpatterns = [
+    path(
+        "llm",
+        SimpleLLMView.as_view(),
+        name="simple-llm",
+    ),
+]

simple_llm/views.py

@@ -0,0 +1,73 @@
+from datetime import datetime
+from _utils.custom_exception_handler import custom_exception_handler_without_api_handler
+from _utils.gerar_documento import gerar_documento
+from _utils.gerar_documento_utils.GerarDocumento import (
+    GerarDocumento,
+    GerarDocumentoUtils,
+)
+from _utils.langchain_utils.Prompt_class import Prompt
+from _utils.utils import convert_markdown_to_HTML
+from setup.logging import Axiom
+from setup.easy_imports import (
+    Response,
+    AsyncAPIView,
+    extend_schema,
+)
+from simple_llm.serializer import SimpleLLMSerializer
+
+
+class SimpleLLMView(AsyncAPIView):
+    # parser_classes = [MultiPartParser]
+    serializer = {}
+    axiom_instance = Axiom()
+
+    @extend_schema(
+        request=SimpleLLMSerializer,
+    )
+    async def post(self, request):
+        try:
+            self.axiom_instance.generate_new_uuid()
+            print(f"\n\nDATA E HORA DA REQUISIÇÃO: {datetime.now()}")
+            self.axiom_instance.send_axiom(
+                f"COMEÇOU NOVA REQUISIÇÃO - request.data: {request.data}"
+            )
+            serializer = SimpleLLMSerializer(data=request.data)
+            if serializer.is_valid(raise_exception=True):
+                obj = serializer.get_obj()  # type: ignore
+                if not serializer.validated_data:
+                    raise ValueError("Erro no validated_data")
+
+                self.serializer = obj
+
+                listaPDFs = [l.link_arquivo for l in obj.files]
+                self.axiom_instance.send_axiom(f"listaPDFs: {listaPDFs}")
+
+                summarizer = GerarDocumentoUtils(self.axiom_instance)
+
+                prompt_instance = Prompt()
+                prompt = prompt_instance.create_and_invoke_prompt(
+                    obj.prompt,
+                    dynamic_dict={"context": obj.user_text},
+                )
+
+                resposta_llm = (
+                    await summarizer.checar_se_resposta_vazia_do_documento_final(
+                        obj.llm_ultimas_requests, prompt.to_string()
+                    )
+                )
+                self.axiom_instance.send_axiom(f"resposta_llm: {resposta_llm}")
+
+                texto_completo_como_html = convert_markdown_to_HTML(
+                    resposta_llm
+                ).replace("resposta_segunda_etapa:", "<br><br>")
+
+                self.axiom_instance.send_axiom(
+                    f"texto_completo_como_html: {texto_completo_como_html}"
+                )
+
+                return Response({"resposta": texto_completo_como_html})
+        except Exception as e:
+            custom_exception_handler_without_api_handler(
+                e, serializer, self.axiom_instance
+            )
+            raise