Olá tudo bem? Estou fazendo o curso Gemini e Python e estou fazendo um chat bot para me ajudar em um projeto fiz o flask tudo certinho (pelo menos eu não encontrei nenhum erro) e por algum motivo até alguns dias atras estava funcionando normal porém agora ele não está retornando resposta ele fica apenas pensando mas não escreve nada, acho que execedi os limites da api como posso apagar o historico para poder voltar a utilizar?

Código flask:

from time import sleep import uuid from flask import Flask, render_template, request, Response import google.generativeai as genai from dotenv import load_dotenv from personalidade import personas, selecionar_persona from gerenciar_imagem import gerar_imagem_gemini import os

Carregar instruções

with open("integrandoGeminiMatheus/Analisador.txt", "r", encoding="utf-8") as file: instrucoes = file.read()

caminho_imagem_enviada = None UPLOAD_FOLDER = "imagens_temporarias"

Carregar variáveis de ambiente

load_dotenv() CHAVE_API_GOOGLE = os.getenv("GEMINI_API_KEY")

Configurar API Gemini

genai.configure(api_key=CHAVE_API_GOOGLE) MODELO_ESCOLHIDO = "gemini-1.5-pro"

app = Flask(name) app.secret_key = 'mysecretkey'

Criar Chatbot

def criar_chatbot(): configuracao_modelo = { "temperature": 0.1, "max_output_tokens": 8192, }

llm = genai.GenerativeModel(
    model_name=MODELO_ESCOLHIDO,
    system_instruction=instrucoes,
    generation_config=configuracao_modelo
) 

# chatbot = llm.start_chat(history=[]) Historico do chat bot
chatbot = None
return chatbot

chatbot = criar_chatbot()

Função para upload da imagem

@app.route("/upload_imagem", methods=["POST"]) def upload_imagem(): global caminho_imagem_enviada

if "imagem" in request.files:
    imagem_enviada = request.files["imagem"]
    nome_arquivo = str(uuid.uuid4()) + os.path.splitext(imagem_enviada.filename)[1]
    caminho_arquivo = os.path.join(UPLOAD_FOLDER, nome_arquivo)
    imagem_enviada.save(caminho_arquivo)
    caminho_imagem_enviada = caminho_arquivo

    # Retorna o caminho correto para o JavaScript
    return {"caminho": caminho_arquivo}, 200  

return "Nenhum arquivo enviado", 400

def bot(prompt, caminho_imagem=None): maximo_tentativas = 3 repeticao = 0 global caminho_imagem_enviada

while repeticao < maximo_tentativas:
    try:
        personalidade = personas.get(selecionar_persona(prompt), personas["neutra"])

        # Construção correta da mensagem
        mensagem_usuario = f"Considerar essa personalidade para responder a mensagem: {personalidade}. " \
                           f"Responda a seguinte mensagem sempre lembrando do histórico: {prompt}" \
                           "Fazer a leitura da imagem enviada e retornar uma resposta com as características da imagem e classificar ela em apto para venda ou não apto para venda."


        if caminho_imagem:  # Verifica se o caminho da imagem foi passado
            mensagem_usuario += "\nUtilize a imagem enviada para responder a mensagem."
            arquivo_imagem = gerar_imagem_gemini(caminho_imagem)
            resposta = chatbot.send_message([arquivo_imagem, mensagem_usuario])
        else:
            resposta = chatbot.send_message(mensagem_usuario)

        if resposta and resposta.text:
            return resposta.text
        else:
            return "Erro: Nenhuma resposta recebida do Gemini."

    except Exception as erro:
        repeticao += 1
        print(f"Erro na tentativa {repeticao}: {erro}")  # Log para depuração
        sleep(2)

return "Erro no Gemini após várias tentativas."

Rotas Flask

@app.route("/") def home(): return render_template("index.html")

@app.route("/chat", methods=["POST"]) def chat(): prompt = request.json["msg"] caminho_imagem = request.json.get("imagem") # Obtém o caminho da imagem do JSON

resposta = bot(prompt, caminho_imagem)  # Passa o caminho da imagem para a função bot
return resposta

if name == "main": app.run(debug=True)

Oi, Matheus! Como vai?

Primeira opção que podemos tentar é para que tente usar outro modelo, de preferência mais simples, sem ser o pro. Para analisar a lógica do código, que deve está certa já que funcionou em outro momento.

Mas seguindo sua própria sugestão, o problema pode estar ligado ao uso da API do Gemini com histórico de conversas. Quando você usa o chatbot.send_message() com um chat criado por start_chat(), o histórico vai crescendo e pode ultrapassar o limite de tokens permitido (no caso, 8192). Isso pode travar a resposta, fazendo parecer que o bot está apenas "pensando".

No seu código, vi que você declarou o chatbot assim:


chatbot = None

E depois:


chatbot = criar_chatbot()

Mas no criar_chatbot(), você não está usando start_chat() como comentou no código. Isso significa que não está realmente mantendo um histórico. Porém, se em algum momento usou e ainda tem algo em cache ou sessões antigas, o comportamento pode ficar estranho.

Resolva fazendo o seguinte:

Recrie o objeto do chatbot a cada chamada, sem histórico acumulado:


def criar_chatbot():
    configuracao_modelo = {
        "temperature": 0.1,
        "max_output_tokens": 8192,
    }

    llm = genai.GenerativeModel(
        model_name=MODELO_ESCOLHIDO,
        system_instruction=instrucoes,
        generation_config=configuracao_modelo
    )

    return llm  # sem .start_chat()

No lugar de chatbot.send_message(), faça direto com o modelo:


chatbot = criar_chatbot()
resposta = chatbot.generate_content(mensagem_usuario)

Código sem acento para facilitar teste:


mensagem = "Qual a capital do Brasil?"
chatbot = criar_chatbot()
resposta = chatbot.generate_content(mensagem)
print(resposta.text)

Faça esses testes, que são gerais, em caso de persistência compartilhe seu projeto comigo.

Espero ter ajudado! Bons estudos!

Sucesso ✨