import gradio as grdo huggingface_hub import InferenceClient
      """"""Para mais informações sobre o suporte da API de Inferência do `huggingface_hub`, consulte a documentação: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference""""""client = InferenceClient("Qwen/Qwen2.5-72B-Instruct")
      
      def responder(mensagem,história: list[tuple[str, str]],Mensagem do sistema,max_tokens,temperatura,top_p,):mensagens = [{"papel": "sistema", "conteúdo": system_message}]
      for val in history:if val[0]:messages.append({"role": "user", "content": val[0]})if val[1]:messages.append({"role": "assistant", "content": val[1]})
      messages.append({"role": "user", "content": message})
      response = ""
      para mensagem em client.chat_completion(mensagens,max_tokens=max_tokens,stream=True,temperature=temperature,top_p=top_p,):token = message.choices[0].delta.content
      response += tokenyield response
      
      """"""Para informações sobre como personalizar a ChatInterface, consulte a documentação do gradio: https://www.gradio.app/docs/chatinterface""""""demo = gr.ChatInterface(responda,```markdown
      additional_inputs=[
      ```gr.Textbox(value="Você é um chatbot amigável. Sempre responda na língua em que o usuário está escrevendo para você.", label="Mensagem do sistema"),gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Máximo de novos tokens"),gr.Slider(mínimo=0,1, máximo=4,0, valor=0,7, passo=0,1, rótulo="Temperatura"),gr.Slider(mínimo=0.1,máximo=1.0,value=0.95,passo=0.05,label="Top-p (amostragem do núcleo)"),],)
      
      if __name__ == "__main__":demo.launch()```
      

---título: SmolLM2emoji: 💬colorFrom: amarelocolorTo: roxosdk: gradiosdk_version: 5.0.1app_file: app.pypinned: falselicença: apache-2.0short_description: Bate-papo com o Gradio SmolLM2---
      Um exemplo de chatbot usando [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index) e a [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).```
      

from fastapi import FastAPI, HTTPExceptionfrom pydantic import BaseModeldo huggingface_hub import InferenceClient
      ```markdown
      from langchain_core.messages import HumanMessage, AIMessage
      ```from langgraph.checkpoint.memory import MemorySaverfrom langgraph.graph import START, MessagesState, StateGraph
      import osfrom dotenv import load_dotenvload_dotenv()```
      
      Carregamos `fastapi` para poder criar as rotas da API, `pydantic` para criar o template das queries, `huggingface_hub` para poder criar um modelo de linguagem, `langchain` para indicar ao modelo se as mensagens são do chatbot ou do usuário e `langgraph` para criar o chatbot.
      Além disso, carregamos `os` e `dotenv` para poder carregar as variáveis de ambiente.
      

# Token da HuggingFaceHUGGINGFACE_TOKEN = os.environ.get("HUGGINGFACE_TOKEN", os.getenv("HUGGINGFACE_TOKEN"))```
      

# Inicializar o modelo da HuggingFacemodel = InferenceClient(model="Qwen/Qwen2.5-72B-Instruct",api_key=os.getenv("HUGGINGFACE_TOKEN"))```
      

# Defina a função que chama o modelodef chamar_modelo(estado: MessagesState):""""""Chame o modelo com as mensagens fornecidas
      Argumentos:estado: EstadoMensagens
      Retorna:um dicionário contendo o texto gerado e o ID do thread""""""# Converter mensagens do LangChain para o formato do HuggingFacehf_messages = []for msg in state["messages"]:Se `isinstance(msg, HumanMessage)`:hf_messages.append({"role": "user", "content": msg.content})elif isinstance(msg, AIMessage):hf_messages.append({"role": "assistant", "content": msg.content})    
      # Chamar a APIresposta = modelo.completar_chat(mensagens=hf_mensagens,temperature=0.5,max_tokens=64,top_p=0,7)    
      # Converter a resposta para o formato LangChain```python
      ai_message = AIMessage(content=response.choices[0].message.content)
      ```return {"messages": state["messages"] + [ai_message]}```
      
      Convertemos as mensagens do formato LangChain para o formato HuggingFace, assim podemos usar o modelo de linguagem.
      

class QueryRequest(BaseModel):query: strthread_id: str = "padrão"```
      
      As consultas terão um `query`, a mensagem do usuário, e um `thread_id`, que é o identificador do fio da conversação e mais adiante explicaremos para que o utilizamos.
      

# Definir o gráficoworkflow = StateGraph(state_schema=MessagesState)
      # Defina o nódo na gráficoworkflow.add_edge(START, "model")workflow.add_node("modelo", call_model)
      # Adicionar memóriamemory = MemorySaver()graph_app = workflow.compile(checkpointer=memory)```
      
      Com isso, criamos um grafo de LangGraph, que é uma estrutura de dados que nos permite criar um chatbot e gerenciar o estado do chatbot para nós, ou seja, entre outras coisas, o histórico de mensagens. Dessa forma, não precisamos fazer isso nós mesmos.
      

app = FastAPI(title="LangChain FastAPI", description="API para gerar texto usando LangChain e LangGraph")```
      

# Ponto de entrada Bem-vindo@app.get("/")async def api_home():"""Ponto de entrada Welcome"""return {"detail": "Bem-vindo ao tutorial de FastAPI, Langchain, Docker"}
      # Gerar ponto final@app.post("/generate")async def gerar(request: QueryRequest):""""""Ponto final para gerar texto usando o modelo de linguagem    
      Argumentos:solicitação: QueryRequestquery: strthread_id: str = "padrão"
      Retorna:um dicionário contendo o texto gerado e o ID do thread""""""tente:# Configurar o ID da threadconfig = {"configurable": {"thread_id": request.thread_id}}        
      # Crie a mensagem de entradainput_messages = [HumanMessage(content=request.query)]        
      # Invocar o gráficooutput = graph_app.invoke({"messages": input_messages}, config)        
      # Obter a resposta do modeloresposta = output["messages"][-1].conteúdo        
      return {"generated_text": resposta,"thread_id": request.thread_id}except Exception as e:raise HTTPException(status_code=500, detail=f"Erro ao gerar texto: {str(e)}")```
      
      Criamos o endpoint `/` que nos retornará um texto quando acessarmos a API, e o endpoint `/generate` que é o que usaremos para gerar o texto.
      Se nós olharmos para a função `generate`, temos a variável `config`, que é um dicionário que contém o `thread_id`. Este `thread_id` é o que nos permite ter um histórico de mensagens de cada usuário, desta forma, diferentes usuários podem usar o mesmo endpoint e ter seu próprio histórico de mensagens.
      

if __name__ == "__main__":import uvicornuvicorn.run(app, host="0.0.0.0", port=7860)```
      

from fastapi import FastAPI, HTTPExceptionfrom pydantic import BaseModeldo huggingface_hub import InferenceClient
      ```markdown
      from langchain_core.messages import HumanMessage, AIMessage
      ```from langgraph.checkpoint.memory import MemorySaverfrom langgraph.graph import START, MessagesState, StateGraph
      import osfrom dotenv import load_dotenvload_dotenv()
      # Token da HuggingFaceHUGGINGFACE_TOKEN = os.environ.get("HUGGINGFACE_TOKEN", os.getenv("HUGGINGFACE_TOKEN"))
      # Inicialize o modelo do HuggingFacemodel = InferenceClient(model="Qwen/Qwen2.5-72B-Instruct",api_key=os.getenv("HUGGINGFACE_TOKEN"))
      # Defina a função que chama o modelodef chamar_modelo(estado: EstadoMensagens):""""""Chame o modelo com as mensagens fornecidas
      Argumentos:estado: MensagensState
      Retorna:um dicionário contendo o texto gerado e o ID do thread""""""# Converter mensagens do LangChain para o formato do HuggingFacehf_messages = []for msg in state["messages"]:if isinstance(msg, HumanMessage):hf_messages.append({"role": "user", "content": msg.content})elif isinstance(msg, AIMessage):hf_messages.append({"role": "assistant", "content": msg.content})    
      # Chame a APIresposta = modelo.completar_chat(mensagens=hf_mensagens,temperature=0.5,max_tokens=64,top_p=0,7)    
      # Converter a resposta para o formato LangChain```markdown
      ai_message = AIMessage(content=response.choices[0].message.content)
      ```return {"messages": state["messages"] + [ai_message]}
      # Definir o gráficoworkflow = StateGraph(state_schema=MessagesState)
      # Defina o nó no grafoworkflow.add_edge(START, "model")workflow.add_node("modelo", call_model)
      # Adicionar memóriamemory = MemorySaver()graph_app = workflow.compile(checkpointer=memory)
      # Defina o modelo de dados para o pedidoclass QueryRequest(BaseModel):query: strthread_id: str = "padrão"
      # Criar a aplicação FastAPIapp = FastAPI(title="LangChain FastAPI", description="API para gerar texto usando LangChain e LangGraph")
      # Ponto de entrada Bem-vindo@app.get("/")async def api_home():"""Ponto de entrada Welcome"""return {"detalhe": "Bem-vindo ao tutorial de FastAPI, Langchain, Docker"}
      # Gerar ponto final@app.post("/gerar")async def generate(request: QueryRequest):"""Ponto final para gerar texto usando o modelo de linguagem    
      Argumentos:solicitação: QueryRequestquery: strthread_id: str = "padrão"
      Retorna:um dicionário contendo o texto gerado e o ID do fio"""tente:# Configurar o ID da threadconfig = {"configurable": {"thread_id": request.thread_id}}        
      # Criar a mensagem de entradainput_messages = [HumanMessage(content=request.query)]        
      # Invocar o gráficooutput = graph_app.invoke({"messages": input_messages}, config)        
      # Obter a resposta do modeloresposta = output["messages"][-1].conteúdo        
      return {"generated_text": resposta,"thread_id": request.thread_id}except Exception as e:raise HTTPException(status_code=500, detail=f"Erro ao gerar texto: {str(e)}")
      if __name__ == "__main__":import uvicornuvicorn.run(app, host="0.0.0.0", port=7860)```
      

FROM python:3.13-slim```
      

RUN useradd -m -u 1000 userWORKDIR /app```
      

COPY --chown=user ./requirements.txt requirements.txtRUN pip install --no-cache-dir --upgrade -r requirements.txt```
      

COPY --chown=user . /app```
      

EXPOSE 7860```
      

RUN --mount=type=secret,id=HUGGINGFACE_TOKEN,mode=0444,required=true \test -f /run/secrets/HUGGINGFACE_TOKEN && echo "Segredo existe!"```
      

CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]```
      

FROM python:3.13-slim
      RUN useradd -m -u 1000 userWORKDIR /app
      COPY --chown=user ./requirements.txt requirements.txtRUN pip install --no-cache-dir --upgrade -r requirements.txt
      COPY --chown=user . /app
      EXPOSE 7860
      RUN --mount=type=secret,id=HUGGINGFACE_TOKEN,mode=0444,required=true \test -f /run/secrets/HUGGINGFACE_TOKEN && echo "Segredo existe!"
      CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]```
      

---título: Backend do SmolLM2emoji: 📊colorFrom: amarelocolorTo: vermelhosdk: dockerpinned: falselicença: apache-2.0short_description: Backend do chat SmolLM2app_port: 7860---
      # Backend do SmolLM2
      Este projeto implementa uma API FastAPI que usa LangChain e LangGraph para gerar texto com o modelo Qwen2.5-72B-Instruct do HuggingFace.
      ## Configuração
      ### No HuggingFace Spaces
      Este projeto está projetado para ser executado em HuggingFace Spaces. Para configurá-lo:
      1. Crie um novo Espaço no HuggingFace com o SDK Docker2. Configure a variável de ambiente `HUGGINGFACE_TOKEN` ou `HF_TOKEN` na configuração do Space:- Vá para a aba "Configurações" do seu Espaço- Role para a seção "Secrets do repositório"- Adicione uma nova variável com o nome `HUGGINGFACE_TOKEN` e seu token como valor- Salve as alterações
      ### Desenvolvimento local
      Para o desenvolvimento local:
      1. Clone este repositório2. Crie um arquivo `.env` na raiz do projeto com seu token do HuggingFace:```
      ```HUGGINGFACE_TOKEN=seu_token_aqui```
      ```3. Instale as dependências:```
      ```pip install -r requirements.txt```
      Por favor, forneça o texto em Markdown que você gostaria de traduzir para o português.
      

from transformers import AutoModelForCausalLM, AutoTokenizerimport torch```
      

# Carregar o modelo e o tokenizermodel_name = "HuggingFaceTB/SmolLM2-1.7B-Instruct"tokenizer = AutoTokenizer.from_pretrained(model_name)model = AutoModelForCausalLM.from_pretrained(nome_do_modelo,torch_dtype=torch.float16,device_map="auto")```
      
      Utilizo `HuggingFaceTB/SmolLM2-1.7B-Instruct` porque é um modelo bastante capaz com apenas 1.7B de parâmetros. Como escolhi o hardware mais básico, não posso usar modelos muito grandes. Você, se quiser usar um modelo maior, tem duas opções: usar o hardware gratuito e aceitar que a inferência será mais lenta, ou usar um hardware mais potente, mas pago.
      

def responder(mensagem,histórico: list[tuple[str, str]],Mensagem do sistema,max_tokens,temperatura,top_p,):# Construir o prompt com o formato corretoprompt = f"<|system|>\n{system_message}</s>\n"    
      for val in history:if val[0]:prompt += f"<|user|>\n{val[0]}</s>\n"if val[1]:prompt += f"<|assistant|>\n{val[1]}</s>\n"    
      prompt += f"<|user|>\n{message}</s>\n<|assistant|>\n"    
      # Tokenizar o promptinputs = tokenizer(prompt, return_tensors="pt").to(model.device)    
      # Gerar a respostaoutputs = model.generate(**entradas,**max_new_tokens=max_tokens,temperature=temperature,top_p=top_p,do_sample=True,pad_token_id=tokenizer.eos_token_id)    
      # Decodificar a respostaresponse = tokenizer.decode(outputs[0], skip_special_tokens=True)    
      # Extrair apenas a parte da resposta do assistenteresponse = response.split("<|assistant|>\n")[-1].strip()    
      yield response```
      

import gradio as grfrom transformers import AutoModelForCausalLM, AutoTokenizerimport torch
      """"""Para mais informações sobre o suporte à API de Inferência do `huggingface_hub`, consulte a documentação: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference""""""
      # Carregar o modelo e o tokenizermodel_name = "HuggingFaceTB/SmolLM2-1.7B-Instruct"tokenizer = AutoTokenizer.from_pretrained(model_name)model = AutoModelForCausalLM.from_pretrained(nome_do_modelo,torch_dtype=torch.float16,device_map="auto")
      def responder(mensagem,história: list[tuple[str, str]],Mensagem do sistema,max_tokens,temperatura,top_p,):# Construir o prompt com o formato corretoprompt = f"<|system|>\n{system_message}</s>\n"    
      for val in history:if val[0]:prompt += f"<|user|>\n{val[0]}</s>\n"if val[1]:prompt += f"<|assistant|>\n{val[1]}</s>\n"    
      prompt += f"<|user|>\n{message}</s>\n<|assistant|>\n"    
      # Tokenizar o promptinputs = tokenizer(prompt, return_tensors="pt").to(model.device)    
      # Gerar a respostasaídas = modelo.gerar(**entradas,**max_new_tokens=max_tokens,temperature=temperature,top_p=top_p,do_sample=True,pad_token_id=tokenizer.eos_token_id)    
      # Decodificar a respostaresponse = tokenizer.decode(outputs[0], skip_special_tokens=True)    
      # Extrair apenas a parte da resposta do assistenteresponse = response.split("<|assistant|>\n")[-1].strip()    
      yield response
      
      """"""Para informações sobre como personalizar o ChatInterface, consulte a documentação do Gradio: https://www.gradio.app/docs/chatinterface""""""demo = gr.ChatInterface(responda,```markdown
      additional_inputs=[
      ```gr.Textbox(value="Você é um Chatbot amigável. Sempre responda na língua em que o usuário está escrevendo para você."rótulo="Mensagem do sistema"),gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Máximo de novos tokens"),gr.Slider(mínimo=0,1, máximo=4,0, valor=0,7, passo=0,1, rótulo="Temperatura"),gr.Slider()mínimo=0.1,máximo=1.0,value=0.95,passo=0.05,label="Top-p (amostragem do núcleo)"),],)
      
      if __name__ == "__main__":demo.launch()```
      

from transformers import AutoModelForCausalLM, AutoTokenizerimport torch```
      

# Inicialize o modelo e o tokenizadorprint("Carregando modelo e tokenizer...")dispositivo = "cuda" if torch.cuda.is_available() else "cpu"model_name = "HuggingFaceTB/SmolLM2-1.7B-Instruct"
      tente:# Carregar o modelo no formato BF16 para melhor desempenho e menor uso de memóriatokenizer = AutoTokenizer.from_pretrained(model_name)    
      if device == "cuda":print("Usando GPU para o modelo...")model = AutoModelForCausalLM.from_pretrained(nome_do_modelo,torch_dtype=torch.bfloat16,device_map="auto",low_cpu_mem_usage=True)else:print("Usando CPU para o modelo...")model = AutoModelForCausalLM.from_pretrained(nome_do_modelo,device_map={"": device},torch_dtype=torch.float32)
      print(f"Modelo carregado com sucesso em: {device}")except Exception as e:print(f"Erro ao carregar o modelo: {str(e)}")aumentar```
      

# Defina a função que chama o modelodef chamar_modelo(estado: EstadoMensagens):"""Chame o modelo com as mensagens fornecidas
      Argumentos:estado: EstadoMensagens
      Retorna:dicionário: Um dicionário contendo o texto gerado e o ID do thread""""""# Converter mensagens LangChain para formato de bate-papomensagens = []for msg in state["messages"]:if isinstance(msg, HumanMessage):messages.append({"role": "user", "content": msg.content})elif isinstance(msg, AIMessage):messages.append({"role": "assistant", "content": msg.content})    
      # Prepare o input usando o modelo de bate-papoinput_text = tokenizer.apply_chat_template(messages, tokenize=False)inputs = tokenizer.encode(input_text, return_tensors="pt").to(device)    
      # Gerar respostasaídas = modelo.gerar(entradas,max_new_tokens=512,  # Aumente o número de tokens para respostas mais longastemperature=0.7,top_p=0,9,do_sample=True,pad_token_id=tokenizer.eos_token_id)    
      # Decodificar e limpar a respostaresponse = tokenizer.decode(outputs[0], skip_special_tokens=True)# Extrair apenas a resposta do assistente (após a última mensagem do usuário)response = response.split("Assistant:")[-1].strip()    
      # Converter a resposta para o formato LangChain```markdown
      ai_message = AIMessage(content=response)
      ```return {"messages": state["messages"] + [ai_message]}```
      

FROM python:3.13-slim
      RUN useradd -m -u 1000 userWORKDIR /app
      COPY --chown=user ./requirements.txt requirements.txtRUN pip install --no-cache-dir --upgrade -r requirements.txt
      COPY --chown=user . /app
      EXPOSE 7860
      CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]```