Treinando um Chatbot com Seus Dados

pip install langchain streamlit chromadb sentence-transformers \
            pypdf2 python-docx pandas

# data_processor.py
import os
import pandas as pd
from langchain.document_loaders import PyPDFLoader, TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import Chroma

class DocumentProcessor:
    def __init__(self):
        self.embeddings = HuggingFaceEmbeddings(
            model_name="sentence-transformers/all-MiniLM-L6-v2"
        )
        self.text_splitter = RecursiveCharacterTextSplitter(
            chunk_size=1000,
            chunk_overlap=200,
            length_function=len
        )
    
    def load_documents(self, folder_path):
        """Carrega documentos de uma pasta"""
        documents = []
        
        for filename in os.listdir(folder_path):
            file_path = os.path.join(folder_path, filename)
            
            if filename.endswith('.pdf'):
                loader = PyPDFLoader(file_path)
                documents.extend(loader.load())
            
            elif filename.endswith('.txt'):
                loader = TextLoader(file_path)
                documents.extend(loader.load())
            
            # Adicione outros tipos de arquivo conforme necessário
        
        return documents
    
    def process_documents(self, documents):
        """Processa e cria chunks dos documentos"""
        chunks = self.text_splitter.split_documents(documents)
        return chunks
    
    def create_knowledge_base(self, chunks, persist_directory="./knowledge_base"):
        """Cria base de conhecimento vetorial"""
        vectordb = Chroma.from_documents(
            documents=chunks,
            embedding=self.embeddings,
            persist_directory=persist_directory
        )
        return vectordb

# Exemplo de uso
if __name__ == "__main__":
    processor = DocumentProcessor()
    
    # Carregue seus documentos
    documents = processor.load_documents("./meus_documentos")
    
    # Processe em chunks
    chunks = processor.process_documents(documents)
    
    # Crie base de conhecimento
    vectordb = processor.create_knowledge_base(chunks)
    
    print(f"✅ Base de conhecimento criada com {len(chunks)} chunks!")

# chatbot.py
import streamlit as st
from langchain.vectorstores import Chroma
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.llms import Ollama
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate

class CustomChatbot:
    def __init__(self, knowledge_base_path="./knowledge_base"):
        # Inicializar embeddings
        self.embeddings = HuggingFaceEmbeddings(
            model_name="sentence-transformers/all-MiniLM-L6-v2"
        )
        
        # Carregar base de conhecimento
        self.vectordb = Chroma(
            persist_directory=knowledge_base_path,
            embedding_function=self.embeddings
        )
        
        # Inicializar LLM local (Ollama)
        self.llm = Ollama(
            model="llama3.2",
            temperature=0.1  # Mais conservador para dados específicos
        )
        
        # Criar template de prompt personalizado
        self.prompt_template = """
        Você é um assistente especializado com acesso a uma base de conhecimento específica.
        Use apenas as informações fornecidas no contexto para responder à pergunta.
        Se não souber a resposta com base no contexto, diga que não tem essa informação.
        
        Contexto: {context}
        
        Pergunta: {question}
        
        Resposta detalhada:
        """
        
        self.prompt = PromptTemplate(
            template=self.prompt_template,
            input_variables=["context", "question"]
        )
        
        # Criar chain RAG
        self.qa_chain = RetrievalQA.from_chain_type(
            llm=self.llm,
            chain_type="stuff",
            retriever=self.vectordb.as_retriever(search_kwargs={"k": 3}),
            chain_type_kwargs={"prompt": self.prompt}
        )
    
    def ask(self, question):
        """Fazer pergunta ao chatbot"""
        try:
            response = self.qa_chain.run(question)
            return response
        except Exception as e:
            return f"Erro ao processar pergunta: {str(e)}"
    
    def search_similar(self, query, k=3):
        """Buscar documentos similares"""
        results = self.vectordb.similarity_search(query, k=k)
        return results

# Exemplo de uso
if __name__ == "__main__":
    chatbot = CustomChatbot()
    
    while True:
        pergunta = input("\n🤖 Digite sua pergunta (ou 'quit' para sair): ")
        if pergunta.lower() == 'quit':
            break
            
        resposta = chatbot.ask(pergunta)
        print(f"\n📝 Resposta: {resposta}")
        print("-" * 50)

# app.py
import streamlit as st
from chatbot import CustomChatbot
import time

# Configuração da página
st.set_page_config(
    page_title="Meu Chatbot Especialista",
    page_icon="🤖",
    layout="wide"
)

# CSS customizado
st.markdown("""

""", unsafe_allow_html=True)

# Inicializar chatbot
@st.cache_resource
def load_chatbot():
    return CustomChatbot()

# Título da aplicação
st.title("🤖 Meu Assistente Especializado")
st.markdown("---")

# Sidebar com informações
with st.sidebar:
    st.header("📊 Informações")
    st.info("Este chatbot foi treinado com dados específicos da sua organização.")
    
    st.header("🔧 Configurações")
    show_sources = st.checkbox("Mostrar fontes", value=True)
    max_tokens = st.slider("Tamanho da resposta", 100, 1000, 500)

# Área principal
chatbot = load_chatbot()

# Histórico de mensagens
if "messages" not in st.session_state:
    st.session_state.messages = []

# Exibir histórico
for message in st.session_state.messages:
    if message["role"] == "user":
        st.markdown(f"""
        

            
👤
            
{message["content"]}
        
        """, unsafe_allow_html=True)
    else:
        st.markdown(f"""
        

            
🤖
            
{message["content"]}
        
        """, unsafe_allow_html=True)

# Input para nova pergunta
pergunta = st.chat_input("Digite sua pergunta aqui...")

if pergunta:
    # Adicionar pergunta do usuário
    st.session_state.messages.append({"role": "user", "content": pergunta})
    
    # Mostrar pergunta imediatamente
    st.markdown(f"""
    

        
👤
        
{pergunta}
    
    """, unsafe_allow_html=True)
    
    # Gerar resposta
    with st.spinner("🤔 Pensando..."):
        resposta = chatbot.ask(pergunta)
    
    # Adicionar resposta do bot
    st.session_state.messages.append({"role": "bot", "content": resposta})
    
    # Mostrar resposta
    st.markdown(f"""
    

        
🤖
        
{resposta}
    
    """, unsafe_allow_html=True)
    
    # Mostrar fontes se solicitado
    if show_sources:
        with st.expander("📚 Ver fontes utilizadas"):
            docs = chatbot.search_similar(pergunta, k=2)
            for i, doc in enumerate(docs, 1):
                st.write(f"**Fonte {i}:**")
                st.write(doc.page_content[:300] + "...")
                if doc.metadata:
                    st.write(f"*Arquivo: {doc.metadata.get('source', 'Desconhecido')}*")
                st.write("---")

# Botão para limpar histórico
if st.sidebar.button("🗑️ Limpar Conversa"):
    st.session_state.messages = []
    st.experimental_rerun()

# Instruções
with st.sidebar.expander("❓ Como usar"):
    st.write("""
    1. Digite sua pergunta na caixa de texto
    2. O chatbot buscará na base de conhecimento
    3. Receberá uma resposta baseada nos seus dados
    4. Use 'Mostrar fontes' para ver de onde veio a informação
    """)

# Estatísticas
if st.sidebar.button("📊 Estatísticas da Base"):
    st.sidebar.write(f"📚 Documentos na base: {chatbot.vectordb._collection.count()}")