> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mka1.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Usar arquivos e lojas vetoriais

> Envie arquivos para a API MKA1, indexe-os em uma loja vetorial e realize buscas semânticas sobre os fragmentos de documentos resultantes.

Use Arquivos para enviar documentos uma única vez.
Use Lojas Vetoriais para indexar esses arquivos para busca semântica e recuperação.

Esse é o padrão recomendado para assistentes baseados em documentos, fluxos de trabalho de recuperação e respostas fundamentadas.

## Enviar um arquivo

Envie o arquivo usando `multipart/form-data`.
A especificação OpenAPI exige `file` e `purpose`.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm files upload \
    --file ./support-manual.pdf \
    --purpose assistants \
    -H 'X-On-Behalf-Of: <end-user-id>'
  ```

  ```ts MKA1 SDK theme={null}
  import { SDK } from '@meetkai/mka1';

  const mka1 = new SDK({ apiKey: '<mka1-api-key>' });

  const file = Bun.file('./support-manual.pdf');
  const result = await mka1.llm.files.upload(
    { file, purpose: 'assistants' },
    { headers: { 'X-On-Behalf-Of': '<end-user-id>' } }
  );
  ```

  ```ts OpenAI SDK theme={null}
  import OpenAI from 'openai';
  import fs from 'fs';

  const openai = new OpenAI({
    apiKey: '<mka1-api-key>',
    baseURL: 'https://apigw.mka1.com/api/v1/llm',
    defaultHeaders: { 'X-On-Behalf-Of': '<end-user-id>' },
  });

  const file = await openai.files.create({
    file: fs.createReadStream('./support-manual.pdf'),
    purpose: 'assistants',
  });
  ```

  ```csharp C# SDK theme={null}
  using MeetKai.MKA1;
  using MeetKai.MKA1.Types.Components;
  using MeetKai.MKA1.Types.Requests;

  var sdk = new SDK(
      bearerAuth: $"Bearer {YOUR_API_KEY}",
      serverUrl: "https://apigw.mka1.com"
  );

  var res = await sdk.Llm.Files.UploadAsync(new UploadFileRequestBody()
  {
      File = new UploadFileFile()
      {
          FileName = "support-manual.pdf",
          Content = System.IO.File.ReadAllBytes("./support-manual.pdf"),
      },
      Purpose = UploadFilePurpose.Assistants,
  });
  ```

  ```python Python SDK theme={null}
  from mka1 import SDK

  sdk = SDK(bearer_auth="Bearer YOUR_API_KEY")

  result = sdk.llm.files.upload(
      file={
          "file_name": "support-manual.pdf",
          "content": open("./support-manual.pdf", "rb"),
      },
      purpose="assistants",
  )
  ```

  ```bash bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/files \
    --request POST \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --form 'file=@./support-manual.pdf' \
    --form 'purpose=assistants'
  ```
</CodeGroup>

A resposta retorna um objeto `file` com um ID como `file-abc123`.

## Criar uma loja vetorial

Crie uma loja vetorial e anexe um ou mais IDs de arquivos enviados.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm vector-stores create --body '{
    "name": "Base de conhecimento de suporte",
    "description": "Manuais de suporte e documentos da central de ajuda indexados",
    "file_ids": ["file-abc123"],
    "expires_after": { "anchor": "last_active_at", "days": 30 }
  }'
  ```

  ```ts MKA1 SDK theme={null}
  const vectorStore = await mka1.llm.vectorStores.create(
    {
      name: 'Base de conhecimento de suporte',
      description: 'Manuais de suporte e documentos da central de ajuda indexados',
      fileIds: ['file-abc123'],
      expiresAfter: { anchor: 'last_active_at', days: 30 },
    },
    { headers: { 'X-On-Behalf-Of': '<end-user-id>' } }
  );
  ```

  ```ts OpenAI SDK theme={null}
  const vectorStore = await openai.vectorStores.create({
    name: 'Base de conhecimento de suporte',
    description: 'Manuais de suporte e documentos da central de ajuda indexados',
    file_ids: ['file-abc123'],
    expires_after: { anchor: 'last_active_at', days: 30 },
  });
  ```

  ```csharp C# SDK theme={null}
  var vs = await sdk.Llm.VectorStores.CreateAsync(new CreateVectorStoreRequest()
  {
      Name = "Base de conhecimento de suporte",
      Description = "Manuais de suporte e documentos da central de ajuda indexados",
  });
  ```

  ```python Python SDK theme={null}
  vector_store = sdk.llm.vector_stores.create(
      name="Base de conhecimento de suporte",
      description="Manuais de suporte e documentos da central de ajuda indexados",
  )
  ```

  ```bash bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/vector_stores \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "name": "Base de conhecimento de suporte",
      "description": "Manuais de suporte e documentos da central de ajuda indexados",
      "file_ids": [
        "file-abc123"
      ],
      "expires_after": {
        "anchor": "last_active_at",
        "days": 30
      }
    }'
  ```
</CodeGroup>

Esta resposta retorna um ID de loja vetorial como `vs_abc123`.

## Adicionar mais arquivos depois

Você pode adicionar mais arquivos a uma loja vetorial existente sem precisar recriá-la.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm vector-stores create-file \
    --vector-store-id vs_abc123 \
    --file-id file-def456 \
    --attributes '{"category":"manual","version":"2.0"}'
  ```

  ```ts MKA1 SDK theme={null}
  const vsFile = await mka1.llm.vectorStores.createFile(
    {
      vectorStoreId: 'vs_abc123',
      fileId: 'file-def456',
      attributes: { category: 'manual', version: '2.0' },
    },
    { headers: { 'X-On-Behalf-Of': '<end-user-id>' } }
  );
  ```

  ```ts OpenAI SDK theme={null}
  const vsFile = await openai.vectorStores.files.create('vs_abc123', {
    file_id: 'file-def456',
  });
  ```

  ```csharp C# SDK theme={null}
  // Adicionar arquivos a uma loja vetorial existente é feito via os métodos
  // VectorStores.CreateFile ou VectorStores.Files da API.
  // Consulte a referência da API para a assinatura completa do método.
  ```

  ```python Python SDK theme={null}
  vs_file = sdk.llm.vector_stores.create_file(
      vector_store_id="vs_abc123",
      file_id="file-def456",
  )
  ```

  ```bash bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/vector_stores/vs_abc123/files \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "file_id": "file-def456",
      "attributes": {
        "category": "manual",
        "version": "2.0"
      }
    }'
  ```
</CodeGroup>

O arquivo da loja vetorial pode retornar `status: "in_progress"` enquanto a indexação está em andamento.
Consulte os endpoints de Arquivos e Lojas Vetoriais na Referência da API caso precise consultar o status.

## Buscar na loja vetorial

Use busca semântica para recuperar os fragmentos mais relevantes para uma pergunta do usuário.

<CodeGroup>
  ```bash CLI theme={null}
  mka1 llm vector-stores search \
    --vector-store-id vs_abc123 \
    --body '{
      "query": "Como faço para redefinir minha senha?",
      "max_num_results": 5
    }'
  ```

  ```ts MKA1 SDK theme={null}
  const results = await mka1.llm.vectorStores.search(
    {
      vectorStoreId: 'vs_abc123',
      searchVectorStoreRequest: {
        query: 'Como faço para redefinir minha senha?',
        maxNumResults: 5,
      },
    },
    { headers: { 'X-On-Behalf-Of': '<end-user-id>' } }
  );
  ```

  ```ts OpenAI SDK theme={null}
  const results = await openai.vectorStores.search('vs_abc123', {
    query: 'Como faço para redefinir minha senha?',
    max_num_results: 5,
  });
  ```

  ```csharp C# SDK theme={null}
  // A busca está disponível via o método VectorStores.Search.
  // Consulte a referência da API para a assinatura completa do método.
  ```

  ```python Python SDK theme={null}
  results = sdk.llm.vector_stores.search(
      vector_store_id="vs_abc123",
      query="Como faço para redefinir minha senha?",
  )
  ```

  ```bash bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/vector_stores/vs_abc123/search \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "query": "Como faço para redefinir minha senha?",
      "max_num_results": 5
    }'
  ```
</CodeGroup>

A resposta retorna correspondências ranqueadas com `file_id`, `filename`, dados de pontuação e conteúdo do fragmento.

## Fluxo de trabalho típico

Use esta sequência para a maioria das configurações de recuperação:

1. Envie o arquivo fonte.
2. Crie uma loja vetorial com `file_ids` ou anexe o arquivo depois.
3. Aguarde o processamento do arquivo ser concluído.
4. Busque na loja vetorial quando precisar de contexto relevante.

Você pode então alimentar o texto retornado na lógica da sua aplicação ou em uma requisição de Respostas.
