Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Fill-In-The-Middle (FIM)

Aula 2 de 14 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. O Princípio Fill-In-The-Middle
  2. O Endpoint /v1/fim/completions
  3. Exemplo Concreto: Completar uma Classe Python
  4. FIM vs. Chat: Escolher a Ferramenta Certa
  5. Maximizar o Potencial do FIM
  6. Pontos-chave

O Princípio Fill-In-The-Middle

O Fill-In-The-Middle, ou FIM, é a capacidade mais distintiva do Codestral. Na geração padrão, um modelo estende o texto a partir de um ponto inicial sem mais nada a considerar. O FIM muda as regras do jogo: permite-lhe preencher uma lacuna no meio do código. Fornece o início, chamado prompt, e o fim, chamado suffix, e o Codestral gera o código intermédio que liga liminarmente os dois.

Este mecanismo resolve um problema muito concreto na conclusão automática de IDEs. Quando escreve no meio de um ficheiro, uma sugestão relevante depende tanto do que se segue ao cursor como do que o precede. Um método inserido entre dois outros deve respeitar o seu estilo, as convenções de nomenclatura e o contrato implícito da classe. Um modelo que vê apenas o contexto a montante propõe código plausível que é frequentemente redundante com o que já existe dez linhas abaixo.

A operação resume-se a três elementos. O prompt contém o código antes do ponto de inserção — por outras palavras, o que já escreveu antes do cursor. O suffix contém o código após o cursor. A conclusão é o fragmento gerado pelo Codestral, que se encaixa entre os dois. O resultado final obedece sempre à mesma equação: prompt + completion + suffix = complete code.

O Endpoint /v1/fim/completions

A Mistral AI expõe o FIM através de um endpoint dedicado. Ao contrário do endpoint de chat padrão, este aceita os parâmetros prompt e suffix em vez de um array de mensagens.

Estrutura do Pedido

from mistralai.client import Mistral

client = Mistral(api_key="your_api_key")

response = client.fim.complete(
    model="codestral-latest",
    prompt="def fibonacci(n: int):",
    suffix="n = int(input('Enter a number: '))\nprint(fibonacci(n))",
    temperature=0,
)

print(response.choices[0].message.content)

Aqui, o Codestral recebe a assinatura da função fibonacci como prompt e o código de chamada como suffix. A sua tarefa é gerar o corpo que transforma esta assinatura numa implementação funcional, sabendo que a função será chamada com um inteiro introduzido via teclado e que o seu valor de retorno será impresso tal como está.

Parâmetros Principais

  • model — sempre "codestral-latest" para FIM
  • prompt — o código antes do cursor (obrigatório)
  • suffix — o código após o cursor (opcional, mas recomendado)
  • temperature — 0 para resultados determinísticos, 0.2-0.7 para variedade
  • max_tokens — limita o comprimento da conclusão gerada
  • stop — lista de tokens de paragem (ex: ["\n\n"] para parar após um bloco)

Exemplo Concreto: Completar uma Classe Python

Vejamos um cenário comum: está a escrever um serviço e falta um método no meio da classe.

prompt = """class UserService:
    def __init__(self, db):
        self.db = db

    def get_user(self, user_id: int):
"""

suffix = """
    def delete_user(self, user_id: int):
        return self.db.execute("DELETE FROM users WHERE id = ?", (user_id,))
"""

response = client.fim.complete(
    model="codestral-latest",
    prompt=prompt,
    suffix=suffix,
    temperature=0,
    max_tokens=200,
)

O suffix faz todo o trabalho pesado no que diz respeito ao contexto. Ao ver delete_user, o Codestral aprende três coisas: a classe consulta a base de dados via self.db.execute, utiliza consultas parametrizadas com ? e devolve o resultado diretamente sem uma camada intermédia. Deduz que get_user deve seguir exatamente o mesmo padrão e gera:

        return self.db.execute("SELECT * FROM users WHERE id = ?", (user_id,))

Tente repetir o exercício sem o suffix e verá a diferença. Privado desta âncora, o modelo inventará frequentemente um ORM ou um cursor que não existe em lado nenhum no seu projeto.

FIM vs. Chat: Escolher a Ferramenta Certa

SituaçãoEndpointPorquê
Conclusão automática num IDEFIMContexto antes E depois do cursor disponível
Gerar uma função completaChatNão é necessário suffix
Completar um ficheiro de configuraçãoFIMFormato e estrutura existentes guiam a conclusão
Explicar códigoChatTarefa em linguagem natural, não conclusão
Escrever testes unitáriosChat ou FIMFIM se o ficheiro de teste já existir parcialmente

Maximizar o Potencial do FIM

A qualidade da conclusão depende primeiro do contexto que fornece. Inclua imports, a classe pai e funções vizinhas no prompt. Estes indicam ao modelo quais as bibliotecas disponíveis e que estilo adotar. O suffix merece atenção especial, pois sem ele, o FIM degrada-se numa geração padrão e perde o seu valor.

No que diz respeito às definições, a conclusão automática de IDE funciona melhor com temperature=0, para que a mesma situação produza sempre a mesma sugestão. Um programador que veja a proposta mudar a cada tecla pressionada acabará por desativá-la. Mantenha o max_tokens baixo, entre 50 e 200, já que está a completar uma linha ou um bloco, não um módulo inteiro. Por fim, os tokens de paragem previnem transbordamentos: stop=["\n\n"] corta a geração no final do bloco atual, em vez de deixar o modelo reescrever metade do ficheiro.

Pontos-chave

  • O FIM completa código entre um prompt (antes) e um suffix (depois)
  • O endpoint dedicado é /v1/fim/completions
  • O resultado é: prompt + completion + suffix = complete code
  • O suffix é essencial para conclusões contextuais de alta qualidade
  • Utilize temperature=0 e limites de tokens para conclusão automática em IDE