Codigo refatorado, variaveis de ambiente precisam estar setadas (#6)

- Codigo refatorado, variaveis de ambiente precisam estar setadas (2f09a6ec8bb4effc64ce04b34d7ae2adb696a28a)


Co-authored-by: Gabriel Silva Rodrigues <[email protected]>

Dockerfile

@@ -27,4 +27,4 @@ COPY --chown=user . $HOME/app
 EXPOSE 7860
 
 # Comando para iniciar o Flask em segundo plano e o Streamlit
-CMD ["sh", "-c", "python app.py & streamlit run app.py --server.port 7860 --server.address 0.0.0.0"]
+CMD ["sh", "-c", "python chatbot_server.py & streamlit run app.py --server.port 7860 --server.address 0.0.0.0"]

app.py

@@ -1,545 +1,104 @@
-import logging
-import sys
-import os
-
-import re
-import base64
-import nest_asyncio
-nest_asyncio.apply()
-import pandas as pd
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-from PIL import Image
 import streamlit as st
-import torch
-
-# Imports do LlamaIndex
-from llama_index.core import (
-    Settings, 
-    SimpleDirectoryReader, 
-    StorageContext, 
-    Document
-)
-
-from llama_index.core.storage.docstore import SimpleDocumentStore
-from llama_index.core.node_parser import LangchainNodeParser
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from llama_index.core.storage.chat_store import SimpleChatStore
-from llama_index.core.memory import ChatMemoryBuffer
-from llama_index.core.query_engine import RetrieverQueryEngine
-from llama_index.core.chat_engine import CondensePlusContextChatEngine
-from llama_index.core.retrievers import QueryFusionRetriever
-from llama_index.vector_stores.chroma import ChromaVectorStore
-from llama_index.core import VectorStoreIndex
-
-import chromadb
-
-###############################################################################
-#                           MONKEY PATCH EM bm25s                             #
-###############################################################################
-import bm25s
-###############################################################################
-#                   CLASSE BM25Retriever (AJUSTADA PARA ENCODING)             #
-###############################################################################
-import json
-import Stemmer
-
-from llama_index.core.base.base_retriever import BaseRetriever
-from llama_index.core.callbacks.base import CallbackManager
-from llama_index.core.constants import DEFAULT_SIMILARITY_TOP_K
-from llama_index.core.schema import (
-    BaseNode,
-    IndexNode,
-    NodeWithScore,
-    QueryBundle,
-    MetadataMode,
-)
-from llama_index.core.vector_stores.utils import (
-    node_to_metadata_dict,
-    metadata_dict_to_node,
-)
-from typing import cast
-
-logger = logging.getLogger(__name__)
-
-DEFAULT_PERSIST_ARGS = {"similarity_top_k": "similarity_top_k", "_verbose": "verbose"}
-DEFAULT_PERSIST_FILENAME = "retriever.json"
-
-
-class BM25Retriever(BaseRetriever):
-    """
-    Implementação customizada do algoritmo BM25 com a lib bm25s, incluindo um
-    'monkey patch' para contornar problemas de decodificação de caracteres.
-    """
-
-    def __init__(
-        self,
-        nodes: Optional[List[BaseNode]] = None,
-        stemmer: Optional[Stemmer.Stemmer] = None,
-        language: str = "en",
-        existing_bm25: Optional[bm25s.BM25] = None,
-        similarity_top_k: int = DEFAULT_SIMILARITY_TOP_K,
-        callback_manager: Optional[CallbackManager] = None,
-        objects: Optional[List[IndexNode]] = None,
-        object_map: Optional[dict] = None,
-        verbose: bool = False,
-    ) -> None:
-        self.stemmer = stemmer or Stemmer.Stemmer("english")
-        self.similarity_top_k = similarity_top_k
-
-        if existing_bm25 is not None:
-            # Usa instância BM25 existente
-            self.bm25 = existing_bm25
-            self.corpus = existing_bm25.corpus
-        else:
-            # Cria uma nova instância BM25 a partir de 'nodes'
-            if nodes is None:
-                raise ValueError("É preciso fornecer 'nodes' ou um 'existing_bm25'.")
+import requests
+from PIL import Image
+import base64
 
-            self.corpus = [node_to_metadata_dict(node) for node in nodes]
-            corpus_tokens = bm25s.tokenize(
-                [node.get_content(metadata_mode=MetadataMode.EMBED) for node in nodes],
-                stopwords=language,
-                stemmer=self.stemmer,
-                show_progress=verbose,
-            )
-            self.bm25 = bm25s.BM25()
-            self.bm25.index(corpus_tokens, show_progress=verbose)
 
-        super().__init__(
-            callback_manager=callback_manager,
-            object_map=object_map,
-            objects=objects,
-            verbose=verbose,
-        )
+class ChatbotApp:
+    def __init__(self):
+        # URL do backend (Flask)
+        self.backend_url = "http://localhost:5001/chat"
+        self.title = "Chatbot Carômetro"
+        self.description = "Este assistente virtual pode te ajudar com informações sobre carômetros da Sicoob."
 
-    @classmethod
-    def from_defaults(
-        cls,
-        index: Optional[VectorStoreIndex] = None,
-        nodes: Optional[List[BaseNode]] = None,
-        docstore: Optional["BaseDocumentStore"] = None,
-        stemmer: Optional[Stemmer.Stemmer] = None,
-        language: str = "en",
-        similarity_top_k: int = DEFAULT_SIMILARITY_TOP_K,
-        verbose: bool = False,
-        tokenizer: Optional[Any] = None,
-    ) -> "BM25Retriever":
-        if tokenizer is not None:
-            logger.warning(
-                "O parâmetro 'tokenizer' foi descontinuado e será removido "
-                "no futuro. Use um Stemmer do PyStemmer para melhor controle."
+    def stream_chat(self, user_input):
+        """
+        Faz a comunicação com o backend e retorna a resposta como streaming de tokens.
+        """
+        try:
+            response = requests.post(
+                self.backend_url,
+                json={"message": user_input},
+                stream=True  # Ativa o streaming
             )
+            response.raise_for_status()
 
-        if sum(bool(val) for val in [index, nodes, docstore]) != 1:
-            raise ValueError("Passe exatamente um entre 'index', 'nodes' ou 'docstore'.")
+            # Gera os tokens conforme chegam no streaming
+            for chunk in response.iter_content(chunk_size=512):
+                if chunk:
+                    yield chunk.decode("utf-8")
+        except Exception as e:
+            yield f"Erro ao conectar ao servidor: {e}"
 
-        if index is not None:
-            docstore = index.docstore
-
-        if docstore is not None:
-            nodes = cast(List[BaseNode], list(docstore.docs.values()))
-
-        assert nodes is not None, (
-            "Não foi possível determinar os nodes. Verifique seus parâmetros."
-        )
-
-        return cls(
-            nodes=nodes,
-            stemmer=stemmer,
-            language=language,
-            similarity_top_k=similarity_top_k,
-            verbose=verbose,
-        )
-
-    def get_persist_args(self) -> Dict[str, Any]:
-        """Dicionário com os parâmetros de persistência a serem salvos."""
-        return {
-            DEFAULT_PERSIST_ARGS[key]: getattr(self, key)
-            for key in DEFAULT_PERSIST_ARGS
-            if hasattr(self, key)
-        }
-
-    def persist(self, path: str, **kwargs: Any) -> None:
+    def render_sidebar(self):
         """
-        Persiste o retriever em um diretório, incluindo
-        a estrutura do BM25 e o corpus em JSON.
+        Exibe opções na barra lateral e renderiza a logo do Sicoob.
         """
-        self.bm25.save(path, corpus=self.corpus, **kwargs)
-        with open(
-            os.path.join(path, DEFAULT_PERSIST_FILENAME),
-            "wt",
-            encoding="utf-8",
-            errors="ignore",
-        ) as f:
-            json.dump(self.get_persist_args(), f, indent=2, ensure_ascii=False)
+        st.sidebar.title("Configuração de LLM")
+        sidebar_option = st.sidebar.radio("Selecione o LLM", ["gpt-3.5-turbo"])
+        if sidebar_option != "gpt-3.5-turbo":
+            raise Exception("Opção de LLM inválida!")
+
+        # Exibe a logo do Sicoob na barra lateral
+        with open("sicoob-logo.png", "rb") as f:
+            data = base64.b64encode(f.read()).decode("utf-8")
+            st.sidebar.markdown(
+                f"""
+                <div style="display:table;margin-top:-80%;margin-left:0%;">
+                    <img src="data:image/png;base64,{data}" width="250" height="70">
+                </div>
+                """,
+                unsafe_allow_html=True,
+            )
 
-    @classmethod
-    def from_persist_dir(cls, path: str, **kwargs: Any) -> "BM25Retriever":
+    def render(self):
         """
-        Carrega o retriever de um diretório, incluindo o BM25 e o corpus.
-        Devido ao nosso patch, ignoramos qualquer erro de decodificação
-        que eventualmente apareça.
+        Renderiza a interface do chatbot.
         """
-        bm25_obj = bm25s.BM25.load(path, load_corpus=True, **kwargs)
-        with open(
-            os.path.join(path, DEFAULT_PERSIST_FILENAME),
-            "rt",
-            encoding="utf-8",
-            errors="ignore",
-        ) as f:
-            retriever_data = json.load(f)
-
-        return cls(existing_bm25=bm25_obj, **retriever_data)
-
-    def _retrieve(self, query_bundle: QueryBundle) -> List[NodeWithScore]:
-        """Recupera nós relevantes a partir do BM25."""
-        query = query_bundle.query_str
-        tokenized_query = bm25s.tokenize(
-            query, stemmer=self.stemmer, show_progress=self._verbose
-        )
-        indexes, scores = self.bm25.retrieve(
-            tokenized_query, k=self.similarity_top_k, show_progress=self._verbose
-        )
-
-        # bm25s retorna lista de listas, pois suporta batched queries
-        indexes = indexes[0]
-        scores = scores[0]
-
-        nodes: List[NodeWithScore] = []
-        for idx, score in zip(indexes, scores):
-            if isinstance(idx, dict):
-                node = metadata_dict_to_node(idx)
-            else:
-                node_dict = self.corpus[int(idx)]
-                node = metadata_dict_to_node(node_dict)
-
-            nodes.append(NodeWithScore(node=node, score=float(score)))
-
-        return nodes
-
-
-###############################################################################
-#                   CONFIGURAÇÃO STREAMLIT E AJUSTES DA PIPELINE             #
-###############################################################################
-# Evite reindexar ou baixar dados repetidamente armazenando o estado na sessão.
-im = Image.open("pngegg.png")
-st.set_page_config(page_title="Chatbot Carômetro", page_icon=im, layout="wide")
-
-# Seções laterais (sidebar)
-st.sidebar.title("Configuração de LLM")
-sidebar_option = st.sidebar.radio("Selecione o LLM", ["gpt-3.5-turbo"])
-
-import base64
-with open("sicoob-logo.png", "rb") as f:
-    data = base64.b64encode(f.read()).decode("utf-8")
-    st.sidebar.markdown(
-        f"""
-        <div style="display:table;margin-top:-80%;margin-left:0%;">
-            <img src="data:image/png;base64,{data}" width="250" height="70">
-        </div>
-        """,
-        unsafe_allow_html=True,
-    )
-
-if sidebar_option == "gpt-3.5-turbo":
-    from llama_index.llms.openai import OpenAI
-    from llama_index.embeddings.openai import OpenAIEmbedding
-    Settings.llm = OpenAI(model="gpt-3.5-turbo")
-    Settings.embed_model = OpenAIEmbedding(model_name="text-embedding-ada-002")
-else:
-    raise Exception("Opção de LLM inválida!")
-
-logging.basicConfig(stream=sys.stdout, level=logging.INFO)
-logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout))
-
-# Caminhos principais
-chat_store_path = os.path.join("chat_store", "chat_store.json")
-documents_path = "documentos"
-chroma_storage_path = "chroma_db"
-bm25_persist_path = "bm25_retriever"
-
-# Classe CSV customizada
-class CustomPandasCSVReader:
-    """PandasCSVReader modificado para incluir cabeçalhos nos documentos."""
-    def __init__(
-        self,
-        *args: Any,
-        concat_rows: bool = True,
-        col_joiner: str = ", ",
-        row_joiner: str = "\n",
-        pandas_config: dict = {},
-        **kwargs: Any
-    ) -> None:
-        self._concat_rows = concat_rows
-        self._col_joiner = col_joiner
-        self._row_joiner = row_joiner
-        self._pandas_config = pandas_config
-
-    def load_data(
-        self,
-        file: Path,
-        extra_info: Optional[Dict] = None,
-    ) -> List[Document]:
-        df = pd.read_csv(file, **self._pandas_config)
-        text_list = [" ".join(df.columns.astype(str))]
-        text_list += (
-            df.astype(str)
-            .apply(lambda row: self._col_joiner.join(row.values), axis=1)
-            .tolist()
-        )
-
-        metadata = {"filename": file.name, "extension": file.suffix}
-        if extra_info:
-            metadata.update(extra_info)
-
-        if self._concat_rows:
-            return [Document(text=self._row_joiner.join(text_list), metadata=metadata)]
-        else:
-            return [
-                Document(text=text, metadata=metadata)
-                for text in text_list
-            ]
-
-def clean_documents(documents: List[Document]) -> List[Document]:
-    """Remove caracteres indesejados diretamente nos textos."""
-    cleaned_docs = []
-    for doc in documents:
-        cleaned_text = re.sub(r"[^0-9A-Za-zÀ-ÿ ]", "", doc.get_content())
-        doc.text = cleaned_text
-        cleaned_docs.append(doc)
-    return cleaned_docs
-
-def are_docs_downloaded(directory_path: str) -> bool:
-    """Verifica se o diretório tem algum arquivo."""
-    return os.path.isdir(directory_path) and any(os.scandir(directory_path))
-
-# Simula a leitura de arquivos do Google Drive
-from llama_index.readers.google import GoogleDriveReader
-import json
-
-credentials_json = os.getenv('GOOGLE_CREDENTIALS')
-token_json = os.getenv('GOOGLE_TOKEN')
-
-if credentials_json is None:
-    raise ValueError("The GOOGLE_CREDENTIALS environment variable is not set.")
-
-# Write the credentials to a file
-credentials_path = "credentials.json"
-token_path = "token.json"
-with open(credentials_path, 'w') as credentials_file:
-    credentials_file.write(credentials_json)
-
-with open(token_path, 'w') as credentials_file:
-    credentials_file.write(token_json)
-    
-google_drive_reader = GoogleDriveReader(credentials_path=credentials_path)
-google_drive_reader._creds = google_drive_reader._get_credentials()
-
-def download_original_files_from_folder(
-    greader: GoogleDriveReader, 
-    pasta_documentos_drive: str, 
-    local_path: str
-):
-    """Faz download dos arquivos apenas se não existirem localmente."""
-    os.makedirs(local_path, exist_ok=True)
-    files_meta = greader._get_fileids_meta(folder_id=pasta_documentos_drive)
-    if not files_meta:
-        logging.info("Nenhum arquivo encontrado na pasta especificada.")
-        return
-    for fmeta in files_meta:
-        file_id = fmeta[0]
-        file_name = os.path.basename(fmeta[2])
-        local_file_path = os.path.join(local_path, file_name)
-
-        if os.path.exists(local_file_path):
-            logging.info(f"Arquivo '{file_name}' já existe localmente, ignorando download.")
-            continue
-
-        downloaded_file_path = greader._download_file(file_id, local_file_path)
-        if downloaded_file_path:
-            logging.info(f"Arquivo '{file_name}' baixado com sucesso em: {downloaded_file_path}")
-        else:
-            logging.warning(f"Não foi possível baixar '{file_name}'")
-
-# Pasta do Drive
-pasta_documentos_drive = "1s0UUANcU1B0D2eyRweb1W5idUn1V5JEh"
-
-###############################################################################
-#           CRIAÇÃO/CARREGAMENTO DE RECURSOS (evita repetição de etapas)      #
-###############################################################################
-# 1. Garantir que não baixamos dados novamente se eles já existem.
-if not are_docs_downloaded(documents_path):
-    logging.info("Baixando arquivos originais do Drive para 'documentos'...")
-    download_original_files_from_folder(
-        google_drive_reader, 
-        pasta_documentos_drive, 
-        documents_path
-    )
-else:
-    logging.info("'documentos' já contém arquivos, ignorando download.")
-
-# 2. Se ainda não existir docstore e index no estado da sessão, criamos.
-#    Caso contrário, apenas reutilizamos o que já existe.
-if "docstore" not in st.session_state:
-    # Carregar documentos do diretório local
-    file_extractor = {".csv": CustomPandasCSVReader()}
-    documents = SimpleDirectoryReader(
-        input_dir=documents_path,
-        file_extractor=file_extractor,
-        filename_as_id=True,
-        recursive=True
-    ).load_data()
-
-    documents = clean_documents(documents)
-
-    # Cria docstore
-    docstore = SimpleDocumentStore()
-    docstore.add_documents(documents)
-
-    st.session_state["docstore"] = docstore
-else:
-    docstore = st.session_state["docstore"]
-
-# 3. Configuramos o VectorStore + Chroma sem recriar se já estiver pronto.
-if "vector_store" not in st.session_state:
-    db = chromadb.PersistentClient(path=chroma_storage_path)
-    chroma_collection = db.get_or_create_collection("dense_vectors")
-    vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
-    st.session_state["vector_store"] = vector_store
-else:
-    vector_store = st.session_state["vector_store"]
-
-storage_context = StorageContext.from_defaults(
-    docstore=docstore, 
-    vector_store=vector_store
-)
-
-# 4. Carregamos ou criamos o índice. Se já existe a base do Chroma, supõe-se
-#    que o índice foi persistido. Caso contrário, cria-se.
-if "index" not in st.session_state:
-    if os.path.exists(chroma_storage_path) and os.listdir(chroma_storage_path):
-        # Há dados salvos, então criamos índice a partir do vector_store
-        index = VectorStoreIndex.from_vector_store(vector_store)
-    else:
-        # Cria índice (chunk_size pode ser configurado conforme necessidade)
-        splitter = LangchainNodeParser(
-            RecursiveCharacterTextSplitter(chunk_size=1024, chunk_overlap=128)
-        )
-        index = VectorStoreIndex.from_documents(
-            list(docstore.docs.values()),
-            storage_context=storage_context,
-            transformations=[splitter]
-        )
-        vector_store.persist()
-    st.session_state["index"] = index
-else:
-    index = st.session_state["index"]
-
-# 5. Criação ou carregamento do BM25Retriever customizado
-if "bm25_retriever" not in st.session_state:
-    if (
-        os.path.exists(bm25_persist_path) 
-        and os.path.exists(os.path.join(bm25_persist_path, "bm25.index.json"))
-    ):
-        bm25_retriever = BM25Retriever.from_persist_dir(bm25_persist_path)
-    else:
-        bm25_retriever = BM25Retriever.from_defaults(
-            docstore=docstore,
-            similarity_top_k=2,
-            language="portuguese",
-            verbose=True
-        )
-        os.makedirs(bm25_persist_path, exist_ok=True)
-        bm25_retriever.persist(bm25_persist_path)
-    st.session_state["bm25_retriever"] = bm25_retriever
-else:
-    bm25_retriever = st.session_state["bm25_retriever"]
-
-# 6. Criamos ou recuperamos o retriever que fará Query Fusion (BM25 + eventual vetor)
-if "fusion_retriever" not in st.session_state:
-    vector_retriever = index.as_retriever(similarity_top_k=2)
-    fusion_retriever = QueryFusionRetriever(
-        [bm25_retriever, vector_retriever],
-        similarity_top_k=2,
-        num_queries=0,
-        mode="reciprocal_rerank",
-        use_async=True,
-        verbose=True,
-        query_gen_prompt=(
-            "Gere {num_queries} perguntas de busca relacionadas à seguinte pergunta. "
-            "Priorize o significado da pergunta sobre qualquer histórico de conversa. "
-            "Se o histórico não for relevante, ignore-o. "
-            "Não adicione explicações ou introduções. Apenas escreva as perguntas. "
-            "Pergunta: {query}\n\nPerguntas:\n"
-        ),
-    )
-    st.session_state["fusion_retriever"] = fusion_retriever
-else:
-    fusion_retriever = st.session_state["fusion_retriever"]
-
-# 7. Configura o Chat Engine caso ainda não esteja na sessão
-if "chat_engine" not in st.session_state:
-    nest_asyncio.apply()
-    memory = ChatMemoryBuffer.from_defaults(token_limit=3900)
-    query_engine = RetrieverQueryEngine.from_args(fusion_retriever)
-
-    chat_engine = CondensePlusContextChatEngine.from_defaults(
-        query_engine,
-        memory=memory,
-        context_prompt=(
-            "Você é um assistente virtual capaz de interagir normalmente, além de "
-            "fornecer informações sobre organogramas e listar funcionários. "
-            "Aqui estão os documentos relevantes para o contexto:\n"
-            "{context_str}\n"
-            "Use o histórico anterior ou o contexto acima para responder."
-        ),
-        verbose=True,
-    )
-    st.session_state["chat_engine"] = chat_engine
-else:
-    chat_engine = st.session_state["chat_engine"]
-
-# 8. Armazenamento do chat
-if "chat_store" not in st.session_state:
-    if os.path.exists(chat_store_path):
-        chat_store = SimpleChatStore.from_persist_path(persist_path=chat_store_path)
-    else:
-        chat_store = SimpleChatStore()
-        chat_store.persist(persist_path=chat_store_path)
-    st.session_state["chat_store"] = chat_store
-else:
-    chat_store = st.session_state["chat_store"]
-
-
-###############################################################################
-#                          INTERFACE DO CHAT EM STREAMLIT                     #
-###############################################################################
-st.title("Chatbot Carômetro")
-st.write("Este assistente virtual pode te ajudar a encontrar informações relevantes sobre os carômetros da Sicoob.")
-
-if 'chat_history' not in st.session_state:
-    st.session_state.chat_history = []
-
-for message in st.session_state.chat_history:
-    role, text = message.split(":", 1)
-    with st.chat_message(role.strip().lower()):
-        st.write(text.strip())
-
-user_input = st.chat_input("Digite sua pergunta")
-if user_input:
-    with st.chat_message('user'):
-        st.write(user_input)
-    st.session_state.chat_history.append(f"user: {user_input}")
-
-    with st.chat_message('assistant'):
-        message_placeholder = st.empty()
-        assistant_message = ''
-
-    response = chat_engine.stream_chat(user_input)
-    for token in response.response_gen:
-        assistant_message += token
-        message_placeholder.markdown(assistant_message + "▌")
-
-    message_placeholder.markdown(assistant_message)
-    st.session_state.chat_history.append(f"assistant: {assistant_message}")
+        # Configura título, ícone e layout da página
+        im = Image.open("pngegg.png")
+        st.set_page_config(page_title="Chatbot Carômetro", page_icon=im, layout="wide")
+
+        # Renderiza a barra lateral
+        self.render_sidebar()
+
+        # Título e descrição
+        st.title(self.title)
+        st.write(self.description)
+
+        # Inicializa o histórico na sessão
+        if "chat_history" not in st.session_state:
+            st.session_state.chat_history = []
+
+        # Renderiza as mensagens do histórico
+        for message in st.session_state.chat_history:
+            role, text = message.split(":", 1)
+            with st.chat_message(role.strip().lower()):
+                st.write(text.strip())
+
+        # Captura o input do usuário
+        user_input = st.chat_input("Digite sua pergunta")
+        if user_input:
+            # Exibe a mensagem do usuário
+            with st.chat_message("user"):
+                st.write(user_input)
+            st.session_state.chat_history.append(f"user: {user_input}")
+
+            # Placeholder para a resposta do assistente
+            with st.chat_message("assistant"):
+                message_placeholder = st.empty()
+                assistant_message = ""
+
+                # Executa o streaming de tokens enquanto o backend responde
+                for token in self.stream_chat(user_input):
+                    assistant_message += token
+                    message_placeholder.markdown(assistant_message + "▌")
+
+                # Atualiza o placeholder com a mensagem final
+                message_placeholder.markdown(assistant_message)
+                st.session_state.chat_history.append(f"assistant: {assistant_message}")
+
+
+if __name__ == "__main__":
+    chatbot_app = ChatbotApp()
+    chatbot_app.render()

chatbot_server.py

@@ -0,0 +1,144 @@
+import os
+import logging
+import sys
+
+from flask import Flask, request, jsonify, Response
+# Inicializa o Flask
+app = Flask(__name__)
+
+logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+
+from llama_index.llms.openai import OpenAI
+from llama_index.embeddings.openai import OpenAIEmbedding
+from llama_index.core import (
+    Settings,
+    SimpleDirectoryReader,
+    StorageContext,
+    Document,
+)
+
+Settings.llm = OpenAI(model="gpt-3.5-turbo")
+Settings.embed_model = OpenAIEmbedding(model_name="text-embedding-3-small")
+directory_path = "documentos"
+from llama_index.readers.file import PDFReader #concatenar todo o documento já vem nativo no pdfreader
+file_extractor = {".pdf": PDFReader(return_full_document = True)}
+from drive_downloader import GoogleDriveDownloader
+
+# ID da pasta no Drive e caminho local
+folder_id = "1n34bmh9rlbOtCvE_WPZRukQilKeabWsN"
+local_path = directory_path
+
+GoogleDriveDownloader().download_from_folder(folder_id, local_path)
+
+documents = SimpleDirectoryReader(
+    input_dir=directory_path,
+    file_extractor=file_extractor,
+    filename_as_id=True,
+    recursive=True
+).load_data()
+
+from document_creator import create_single_document_with_filenames
+document = create_single_document_with_filenames(directory_path = directory_path)
+documents.append(document)
+
+from llama_index.core.ingestion import IngestionPipeline
+#ingestion pipeline vai entrar em uso quando adicionar o extrator de metadados
+from llama_index.core.node_parser import SentenceSplitter
+splitter = SentenceSplitter(chunk_size=1024, chunk_overlap=128)
+nodes = splitter.get_nodes_from_documents(documents)
+#from llama_index.core.extractors import (
+#    SummaryExtractor,
+#)
+#summary = SummaryExtractor(llm = OpenAI(model="gpt-3.5-turbo", system_prompt "Sempre escreva e responda em português brasileiro."))
+#pipeline = IngestionPipeline(
+#    transformations=[splitter, summary]
+#)
+
+#nodes = pipeline.run(
+ #   documents=documents,
+ #   in_place=True,
+#    show_progress=True,
+#)
+
+from llama_index.core.storage.docstore import SimpleDocumentStore
+docstore = SimpleDocumentStore()
+docstore.add_documents(nodes)
+
+from llama_index.core import VectorStoreIndex, StorageContext
+from llama_index.vector_stores.chroma import ChromaVectorStore
+import chromadb
+
+db = chromadb.PersistentClient(path="./storage/chroma_db")
+chroma_collection = db.get_or_create_collection("dense_vectors")
+vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
+storage_context = StorageContext.from_defaults(
+    docstore=docstore, vector_store=vector_store
+    )
+index = VectorStoreIndex(nodes = nodes, storage_context=storage_context, show_progress = True)
+
+storage_context.docstore.persist("./storage/docstore.json")
+
+index_retriever = index.as_retriever(similarity_top_k=2)
+import nest_asyncio
+nest_asyncio.apply()
+from llama_index.retrievers.bm25 import BM25Retriever
+bm25_retriever = BM25Retriever.from_defaults(
+    docstore=index.docstore,
+    similarity_top_k=2,
+    language = "portuguese",
+    verbose=True,
+    )
+
+from llama_index.core.retrievers import QueryFusionRetriever
+
+retriever = QueryFusionRetriever(
+    [index_retriever, bm25_retriever],
+    num_queries=1, #desativado = 1
+    mode="reciprocal_rerank",
+    use_async=True,
+    verbose=True,
+)
+
+from llama_index.core.storage.chat_store import SimpleChatStore
+from llama_index.core.memory import ChatMemoryBuffer
+chat_store = SimpleChatStore()
+chat_memory = ChatMemoryBuffer.from_defaults(
+    token_limit=3000,
+    chat_store=chat_store,
+    chat_store_key="user1",
+)
+from llama_index.core.query_engine import RetrieverQueryEngine
+query_engine = RetrieverQueryEngine.from_args(retriever)
+from llama_index.core.chat_engine import CondensePlusContextChatEngine
+chat_engine = CondensePlusContextChatEngine.from_defaults(
+    query_engine,
+    memory=chat_memory,
+    context_prompt=(
+        "Você é um assistente virtual capaz de interagir normalmente, além de"
+        " fornecer informações sobre organogramas e listar funcionários."
+        " Aqui estão os documentos relevantes para o contexto:\n"
+        "{context_str}"
+        "\nInstrução: Use o histórico da conversa anterior, ou o contexto acima, para responder."
+    ),
+)
+
+
+
+@app.route("/chat", methods=["POST"])
+def chat():
+    user_input = request.json.get("message", "")
+    if not user_input:
+        return jsonify({"error": "Mensagem vazia"}), 400
+
+    def generate_response():
+        try:
+            response = chat_engine.stream_chat(user_input)
+            for token in response.response_gen:
+                yield token  # Envia cada token
+            chat_store.persist(persist_path="./storage/chat_store.json")
+        except Exception as e:
+            yield f"Erro: {str(e)}"
+
+    return Response(generate_response(), content_type="text/plain")
+if __name__ == "__main__":
+    app.run(port=5001, debug=False)

document_creator.py

@@ -0,0 +1,133 @@
+import os
+import re
+from pathlib import Path
+from llama_index.core import Document
+
+def create_single_document_with_filenames(directory_path: str) -> Document:
+    """
+    Percorre a pasta informada, organiza os arquivos em estrutura de anos (YYYY) e meses (MM),
+    gera um texto descritivo semelhante ao código anterior (sem salvar em arquivo) e retorna
+    esse texto dentro de um objeto Document.
+
+    Uso:
+        directory_path = "documentos"
+        doc = create_single_document_with_filenames(directory_path)
+        documents.append(doc)
+    """
+
+    # Dicionário {ano: {mes: [arquivos]}}
+    estrutura_anos = {}
+    # Lista para arquivos fora do padrão YYYY-MM
+    docs_sem_data = []
+    # Conjunto para todos os arquivos (para listagem geral no final)
+    todos_arquivos = set()
+
+    # Percorre o diretório de forma recursiva
+    for root, dirs, files in os.walk(directory_path):
+        match_ano_mes = re.search(r"(\d{4})-(\d{2})", root)
+        if match_ano_mes:
+            ano = match_ano_mes.group(1)
+            mes = match_ano_mes.group(2)
+
+            if ano not in estrutura_anos:
+                estrutura_anos[ano] = {}
+            if mes not in estrutura_anos[ano]:
+                estrutura_anos[ano][mes] = []
+
+            for nome_arq in files:
+                estrutura_anos[ano][mes].append(nome_arq)
+                todos_arquivos.add(nome_arq)
+        else:
+            # Se a pasta não segue o padrão YYYY-MM, consideramos esses arquivos "sem data"
+            for nome_arq in files:
+                docs_sem_data.append(nome_arq)
+                todos_arquivos.add(nome_arq)
+
+    # Montamos o texto final, seguindo a lógica dos "casos"
+    descricao_final = []
+
+    # Organiza a lista de anos e percorre
+    for ano in sorted(estrutura_anos.keys()):
+        meses_ordenados = sorted(estrutura_anos[ano].keys())
+        qtd_meses = len(meses_ordenados)
+
+        # Caso 1: Apenas um mês e um arquivo
+        if qtd_meses == 1:
+            unico_mes = meses_ordenados[0]
+            arquivos_unico_mes = estrutura_anos[ano][unico_mes]
+            if len(arquivos_unico_mes) == 1:
+                nome_mes_extenso = mes_extenso(unico_mes)
+                arquivo_unico = arquivos_unico_mes[0]
+                descricao_final.append(
+                    f"No ano de {ano}, temos somente o mês de {nome_mes_extenso} (mês {unico_mes}), "
+                    f"outros meses não foram listados, e nessa pasta encontramos apenas "
+                    f"um manual chamado {arquivo_unico}."
+                )
+                # pula para o próximo ano
+                continue
+
+        # Caso 2: Mais meses ou mais arquivos em algum mês
+        frase_inicial = f"No ano de {ano}, temos os meses de "
+        meses_descricao = [f"{mes_extenso(m)} (mês {m})" for m in meses_ordenados]
+        frase_inicial += ", ".join(meses_descricao) + "."
+        descricao_final.append(frase_inicial)
+
+        for mes_ in meses_ordenados:
+            arquivos_mes = estrutura_anos[ano][mes_]
+            nome_mes_extenso = mes_extenso(mes_)
+            qtd_arquivos = len(arquivos_mes)
+            if qtd_arquivos == 1:
+                descricao_final.append(
+                    f"Em {nome_mes_extenso} temos somente o manual chamado {arquivos_mes[0]}."
+                )
+            else:
+                descricao_final.append(
+                    f"Em {nome_mes_extenso} temos {qtd_arquivos} manuais, chamados: {', '.join(arquivos_mes)}."
+                )
+
+    # Caso 3: Arquivos sem data
+    if docs_sem_data:
+        docs_sem_data_unicos = list(set(docs_sem_data))
+        if len(docs_sem_data_unicos) == 1:
+            descricao_final.append(
+                f"Em nossos documentos, fora de pastas de data, temos somente este arquivo: {docs_sem_data_unicos[0]}."
+            )
+        else:
+            descricao_final.append(
+                "Em nossos documentos, fora de pastas de data, encontramos estes arquivos: "
+                + ", ".join(docs_sem_data_unicos) + "."
+            )
+
+    # Lista global de todos os arquivos
+    lista_geral_ordenada = sorted(todos_arquivos)
+    descricao_final.append(
+        "Essas são as listas de todos os documentos, manuais e organogramas que podemos "
+        f"resolver, listar e usar para nossas respostas, esses documentos vão ser muito úteis: {', '.join(lista_geral_ordenada)}"
+    )
+
+    # Une o texto final
+    document_text = "\n".join(descricao_final)
+
+    # Cria e retorna um Document com esse texto
+    document = Document(
+        text=document_text,
+        metadata={
+            "description": "Lista de manuais, arquivos e documentos que podemos responder.",
+            "file_name": "Lista de documentos",
+            "summary": "Entre 2011 e 2024, há uma grande variedade de manuais e documentos organizados por ano e mês: alguns anos possuem apenas um mês e um único arquivo, enquanto outros registram diversos períodos, cada um com vários manuais. Adicionalmente, há alguns arquivos “soltos”, fora dessas pastas de data. No fim, existe uma listagem completa de todos os itens, cobrindo instruções bancárias, regulamentos internos e outros materiais de suporte."
+            }
+    )
+    return document
+
+def mes_extenso(mes_str: str) -> str:
+    """
+    Converte '07' em 'Julho', '09' em 'Setembro', etc.
+    """
+    meses_dict = {
+        "01": "Janeiro",   "02": "Fevereiro", "03": "Março",
+        "04": "Abril",     "05": "Maio",      "06": "Junho",
+        "07": "Julho",     "08": "Agosto",    "09": "Setembro",
+        "10": "Outubro",   "11": "Novembro",  "12": "Dezembro"
+    }
+    return meses_dict.get(mes_str, mes_str)
+

drive_downloader.py

@@ -0,0 +1,300 @@
+try:
+    import os
+    import io
+    import json
+    import hashlib
+    from googleapiclient.discovery import build
+    from googleapiclient.http import MediaIoBaseDownload
+    from google.auth.transport.requests import Request
+    from google.oauth2.credentials import Credentials
+    from tqdm import tqdm
+except ImportError as e:
+    # Se faltarem as bibliotecas necessárias, levantamos Exception
+    raise Exception(
+        "Faltam bibliotecas necessárias para o GoogleDriveDownloader. "
+        "Instale-as com:\n\n"
+        "  pip install google-api-python-client google-auth-httplib2 google-auth-oauthlib tqdm\n\n"
+        f"Detalhes do erro: {str(e)}"
+    )
+
+class GoogleDriveDownloader:
+    """
+    Classe para autenticar e baixar arquivos do Google Drive,
+    preservando a estrutura de pastas e evitando downloads redundantes.
+    - Nunca abrirá navegador se não encontrar token válido (apenas levanta exceção).
+    - Pode ler 'credentials.json' e 'token.json' do disco ou das variáveis de ambiente.
+    """
+
+    SCOPES = ['https://www.googleapis.com/auth/drive.readonly']
+    
+    def __init__(self, chunksize=100 * 1024 * 1024):
+        """
+        :param chunksize: Tamanho (em bytes) de cada chunk ao baixar arquivos.
+                          Ex.: 100MB = 100 * 1024 * 1024.
+        """
+        self.chunksize = chunksize
+        self.service = None
+
+    def _get_credentials_from_env_or_file(self):
+        """
+        Verifica se existem variáveis de ambiente para 'CREDENTIALS' e 'TOKEN'.
+        Caso contrário, tenta usar arquivos locais 'credentials.json' e 'token.json'.
+        
+        Se o token local/ambiente não existir ou for inválido (sem refresh),
+        levanta exceção (não abrimos navegador neste fluxo).
+        """
+        print("Procurando credentials na variavel de ambiente...")
+        env_credentials = os.environ.get("CREDENTIALS")  # Conteúdo JSON do client secrets
+        env_token = os.environ.get("TOKEN")              # Conteúdo JSON do token
+
+        creds = None
+
+        # 1) Carregar credenciais do ambiente, se houver
+        if env_credentials:
+            try:
+                creds_json = json.loads(env_credentials)
+            except json.JSONDecodeError:
+                raise ValueError("A variável de ambiente 'CREDENTIALS' não contém JSON válido.")
+            
+            # Validamos o "client_id" para garantir que seja um JSON de credenciais mesmo
+            client_id = (
+                creds_json.get("installed", {}).get("client_id") or
+                creds_json.get("web", {}).get("client_id")
+            )
+            if not client_id:
+                raise ValueError("Credenciais em memória não parecem válidas. Faltam campos 'client_id'.")
+
+        else:
+            # Se não há credenciais no ambiente, tentamos local
+            if not os.path.exists("credentials.json"):
+                raise FileNotFoundError(
+                    "Nenhuma credencial encontrada em ambiente ou no arquivo 'credentials.json'."
+                )
+            print("Variavel não encontrada, usando credentials.json")
+            with open("credentials.json", 'r', encoding='utf-8') as f:
+                creds_json = json.load(f)
+
+        print("Procurando tokens na variavel de ambiente...")
+        token_data = None
+        if env_token:
+            try:
+                token_data = json.loads(env_token)
+            except json.JSONDecodeError:
+                raise ValueError("A variável de ambiente 'TOKEN' não contém JSON válido.")
+        else:
+            # Se não há token no ambiente, checamos arquivo local
+            if os.path.exists("token.json"):
+                print("Variavel não encontrada, usando token.json")
+                with open("token.json", 'r', encoding='utf-8') as tf:
+                    token_data = json.load(tf)
+            else:
+                raise FileNotFoundError(
+                    "Não há token no ambiente nem em 'token.json'. "
+                    "Não é possível autenticar sem abrir navegador, então abortando."
+                )
+        
+        # 3) Criar credenciais a partir do token_data
+        creds = Credentials.from_authorized_user_info(token_data, self.SCOPES)
+
+        # 4) Se expirou, tenta refresh
+        if not creds.valid:
+            if creds.expired and creds.refresh_token:
+                creds.refresh(Request())
+                # Salva token atualizado, se estiver usando arquivo local
+                if not env_token:  # só sobrescreve se está lendo do disco
+                    with open("token.json", 'w', encoding='utf-8') as token_file:
+                        token_file.write(creds.to_json())
+            else:
+                # Se não é válido e não há refresh token, não temos como renovar sem navegador
+                raise RuntimeError(
+                    "As credenciais de token são inválidas/expiradas e sem refresh token. "
+                    "Não é possível abrir navegador neste fluxo, abortando."
+                )
+
+        return creds
+
+    def authenticate(self):
+        """Cria e armazena o serviço do Drive API nesta instância."""
+        creds = self._get_credentials_from_env_or_file()
+        self.service = build("drive", "v3", credentials=creds)
+
+    def _list_files_in_folder(self, folder_id):
+        """Retorna a lista de itens (arquivos/pastas) diretamente em 'folder_id'."""
+        items = []
+        page_token = None
+        query = f"'{folder_id}' in parents and trashed=false"
+
+        while True:
+            response = self.service.files().list(
+                q=query,
+                spaces='drive',
+                fields='nextPageToken, files(id, name, mimeType)',
+                pageToken=page_token
+            ).execute()
+            items.extend(response.get('files', []))
+            page_token = response.get('nextPageToken', None)
+            if not page_token:
+                break
+        return items
+
+    def _get_file_metadata(self, file_id):
+        """
+        Retorna (size, md5Checksum, modifiedTime) de um arquivo no Drive.
+        Se algum campo não existir, retorna valor padrão.
+        """
+        data = self.service.files().get(
+            fileId=file_id,
+            fields='size, md5Checksum, modifiedTime'
+        ).execute()
+
+        size = int(data.get('size', 0))
+        md5 = data.get('md5Checksum', '')
+        modified_time = data.get('modifiedTime', '')
+        return size, md5, modified_time
+
+    def _get_all_items_recursively(self, folder_id, parent_path=''):
+        """
+        Percorre recursivamente a pasta (folder_id) no Drive,
+        retornando lista de dicts (id, name, mimeType, path).
+        """
+        results = []
+        items = self._list_files_in_folder(folder_id)
+
+        for item in items:
+            current_path = os.path.join(parent_path, item['name'])
+            if item['mimeType'] == 'application/vnd.google-apps.folder':
+                results.append({
+                    'id': item['id'],
+                    'name': item['name'],
+                    'mimeType': item['mimeType'],
+                    'path': current_path
+                })
+                sub = self._get_all_items_recursively(item['id'], current_path)
+                results.extend(sub)
+            else:
+                results.append({
+                    'id': item['id'],
+                    'name': item['name'],
+                    'mimeType': item['mimeType'],
+                    'path': parent_path
+                })
+        return results
+
+    def _needs_download(self, local_folder, file_info):
+        """
+        Verifica se o arquivo em 'file_info' precisa ser baixado.
+        - Se não existir localmente, retorna True.
+        - Se existir, compara tamanho e MD5 (quando disponível).
+        - Retorna True se for diferente, False se for idêntico.
+        """
+        file_id = file_info['id']
+        file_name = file_info['name']
+        rel_path = file_info['path']
+
+        drive_size, drive_md5, _ = self._get_file_metadata(file_id)
+        full_local_path = os.path.join(local_folder, rel_path, file_name)
+
+        if not os.path.exists(full_local_path):
+            return True  # Não existe localmente
+
+        local_size = os.path.getsize(full_local_path)
+        if local_size != drive_size:
+            return True
+
+        if drive_md5:
+            with open(full_local_path, 'rb') as f:
+                local_md5 = hashlib.md5(f.read()).hexdigest()
+            if local_md5 != drive_md5:
+                return True
+
+        return False
+
+    def _download_single_file(self, file_id, file_name, relative_path, progress_bar):
+        """
+        Faz download de um único arquivo do Drive, atualizando a barra de progresso global.
+        """
+        # Como fizemos 'os.chdir(local_folder)' antes, 'relative_path' pode ser vazio.
+        # Então concatenamos sem o local_folder:
+        file_path = os.path.join(relative_path, file_name)
+
+        # Se o path do diretório for vazio, cai no '.' para evitar WinError 3
+        dir_name = os.path.dirname(file_path) or '.'
+        os.makedirs(dir_name, exist_ok=True)
+
+        request = self.service.files().get_media(fileId=file_id)
+        with io.FileIO(file_path, 'wb') as fh:
+            downloader = MediaIoBaseDownload(fh, request, chunksize=self.chunksize)
+            done = False
+            previous_progress = 0
+
+            while not done:
+                status, done = downloader.next_chunk()
+                if status:
+                    current_progress = status.resumable_progress
+                    chunk_downloaded = current_progress - previous_progress
+                    previous_progress = current_progress
+                    progress_bar.update(chunk_downloaded)
+
+    def download_from_folder(self, drive_folder_id: str, local_folder: str):
+        """
+        Método principal para:
+         1. Autenticar sem abrir navegador (usa token local/ambiente).
+         2. Exibir "Iniciando verificação de documentos".
+         3. Listar recursivamente arquivos da pasta do Drive.
+         4. Verificar quais precisam de download.
+         5. Baixar apenas o necessário, com barra de progresso única.
+        """
+        print("Iniciando verificação de documentos")
+
+        if not self.service:
+            self.authenticate()
+
+        print("Buscando lista de arquivos no Drive...")
+        all_items = self._get_all_items_recursively(drive_folder_id)
+
+        # Filtra apenas arquivos (exclui subpastas)
+        all_files = [f for f in all_items if f['mimeType'] != 'application/vnd.google-apps.folder']
+
+        print("Verificando quais arquivos precisam ser baixados...")
+        files_to_download = []
+        total_size_to_download = 0
+        for info in all_files:
+            if self._needs_download(local_folder, info):
+                drive_size, _, _ = self._get_file_metadata(info['id'])
+                total_size_to_download += drive_size
+                files_to_download.append(info)
+
+        if not files_to_download:
+            print("Nenhum arquivo novo ou atualizado. Tudo sincronizado!")
+            return
+
+        print("Calculando total de bytes a serem baixados...")
+
+        # Ajusta a pasta local e cria se necessário
+        os.makedirs(local_folder, exist_ok=True)
+
+        # Muda diretório de trabalho para simplificar criação de subpastas
+        old_cwd = os.getcwd()
+        os.chdir(local_folder)
+
+        # Cria a barra de progresso global
+        progress_bar = tqdm(
+            total=total_size_to_download,
+            unit='B',
+            unit_scale=True,
+            desc='Baixando arquivos'
+        )
+
+        # Baixa só o que precisa
+        for file_info in files_to_download:
+            self._download_single_file(
+                file_id=file_info['id'],
+                file_name=file_info['name'],
+                relative_path=file_info['path'],
+                progress_bar=progress_bar
+            )
+
+        progress_bar.close()
+        os.chdir(old_cwd)
+
+        print("Download concluído com sucesso!")

requirements.txt

@@ -1,11 +1,7 @@
-transformers[torch]
-llama_index==0.11.23
-chromadb==0.5.18
-langchain==0.3.7
-nest_asyncio==1.6.0
-llama-index-retrievers-bm25==0.4.0
-bm25s==0.2.6
-llama-index-vector-stores-chroma==0.3.0
-openpyxl
-llama-index-readers-file
-llama-index-readers-google
+llama-index==0.12.12
+llama-index-retrievers-bm25==0.5.2
+llama-index-vector-stores-chroma==0.4.1
+llama-index-readers-google==0.6.0
+openpyxl==3.1.5
+flask==3.1.0
+streamlit==1.41.1