Sobre o Kimi K3.1 Pro
O Kimi K3.1 Pro é um modelo de linguagem da Moonshot AI, lançado em 23 de outubro de 2026. É o primeiro modelo da série Kimi K3.1 e uma versão mais treinada do Kimi K3: o mesmo modelo mixture-of-experts com 2,8 trilhões de parâmetros, 104 bilhões deles ativos em cada token, com muito mais aprendizado por reforço por cima.
A Moonshot criou o modelo para trabalhos longos e com muitas etapas: programação em engines de jogos e Three.js, scripts 3D e CAD para Blender e FreeCAD, pesquisa financeira e documentos de escritório. Ele sempre raciocina antes de responder, lê imagens e vídeo além de texto e mantém até 1 milhão de tokens no contexto.
A Moonshot planeja publicar os pesos até 4 de novembro de 2026. Na Overchat AI, o Kimi K3.1 Pro está no mesmo chat que GPT-6, Claude, Gemini e outros modelos, então dá para trocar de modelo sem começar uma nova conversa.
- Desenvolvedor
- Moonshot AI
- Lançamento
- 23 out. 2026
- Parâmetros
- 2,8T, 104B ativos
- Janela de contexto
- 1M tokens
- Entrada
- Texto, imagens, vídeo
- Saída
- Texto
Veja como o Kimi K3.1 Pro responde
Escreva um script Python para o Blender que crie uma cadeira de madeira simples: quatro pernas, assento e encosto. Coloque todas as medidas em centímetros como variáveis no topo e dê às peças um material de madeira.
Rode no workspace Scripting do Blender. Internamente ele usa metros, enquanto todas as medidas da cadeira ficam em centímetros no topo.
import bpy
# =========================================================
# CHAIR DIMENSIONS — all measurements are in centimeters
# =========================================================
LEG_THICKNESS_CM = 4.0
LEG_HEIGHT_CM = 45.0 # Floor to underside of seat
LEG_INSET_CM = 1.0 # Distance from seat edge to leg's outer face
SEAT_WIDTH_CM = 45.0
SEAT_DEPTH_CM = 45.0
SEAT_THICKNESS_CM = 4.0
BACKREST_WIDTH_CM = 45.0
BACKREST_THICKNESS_CM = 3.0
BACKREST_HEIGHT_CM = 40.0
EDGE_BEVEL_CM = 0.25
BEVEL_SEGMENTS = 3
CM_TO_METERS = 0.01
# Display Blender's measurements in centimeters.
scene = bpy.context.scene
scene.unit_settings.system = 'METRIC'
scene.unit_settings.length_unit = 'CENTIMETERS'
scene.unit_settings.scale_length = 1.0
# Remove only a chair generated by a previous run of this script.
old_collection = bpy.data.collections.get("Wooden Chair")
if old_collection:
for obj in list(old_collection.objects):
bpy.data.objects.remove(obj, do_unlink=True)
bpy.data.collections.remove(old_collection)
chair_collection = bpy.data.collections.new("Wooden Chair")
scene.collection.children.link(chair_collection)
def create_wood_material():
"""Create a simple procedural wood material."""
material = bpy.data.materials.new("Chair Wood")
material.use_nodes = True
material.diffuse_color = (0.42, 0.20, 0.07, 1.0)
nodes = material.node_tree.nodes
links = material.node_tree.links
nodes.clear()
output = nodes.new("ShaderNodeOutputMaterial")
shader = nodes.new("ShaderNodeBsdfPrincipled")
shader.inputs["Roughness"].default_value = 0.4
tex_coord = nodes.new("ShaderNodeTexCoord")
mapping = nodes.new("ShaderNodeMapping")
noise = nodes.new("ShaderNodeTexNoise")
color_ramp = nodes.new("ShaderNodeValToRGB")
# Stretch the noise to suggest wood grain.
mapping.inputs["Scale"].default_value = (4.0, 4.0, 0.35)
noise.inputs["Scale"].default_value = 4.0
noise.inputs["Detail"].default_value = 3.0
noise.inputs["Roughness"].default_value = 0.65
color_ramp.color_ramp.elements[0].position = 0.2
color_ramp.color_ramp.elements[0].color = (0.12, 0.04, 0.012, 1.0)
color_ramp.color_ramp.elements[1].position = 0.8
color_ramp.color_ramp.elements[1].color = (0.52, 0.27, 0.09, 1.0)
links.new(tex_coord.outputs["Generated"], mapping.inputs["Vector"])
links.new(mapping.outputs["Vector"], noise.inputs["Vector"])
links.new(noise.outputs["Fac"], color_ramp.inputs["Fac"])
links.new(color_ramp.outputs["Color"], shader.inputs["Base Color"])
links.new(shader.outputs["BSDF"], output.inputs["Surface"])
return material
wood_material = create_wood_material()
def add_box(name, dimensions_cm, center_cm):
"""Add a wooden rectangular part using centimeter-based inputs."""
bpy.ops.mesh.primitive_cube_add(size=1.0, location=(0.0, 0.0, 0.0))
obj = bpy.context.object
obj.name = name
obj.dimensions = tuple(
value * CM_TO_METERS for value in dimensions_cm
)
bpy.ops.object.transform_apply(
location=False,
rotation=False,
scale=True
)
obj.location = tuple(
value * CM_TO_METERS for value in center_cm
)
# Move the part into the chair collection.
for collection in list(obj.users_collection):
collection.objects.unlink(obj)
chair_collection.objects.link(obj)
obj.data.materials.append(wood_material)
bevel = obj.modifiers.new("Rounded wooden edges", 'BEVEL')
bevel.width = EDGE_BEVEL_CM * CM_TO_METERS
bevel.segments = BEVEL_SEGMENTS
return obj
# Four legs, with their top faces touching the underside of the seat.
leg_x = (
SEAT_WIDTH_CM / 2.0
- LEG_INSET_CM
- LEG_THICKNESS_CM / 2.0
)
leg_y = (
SEAT_DEPTH_CM / 2.0
- LEG_INSET_CM
- LEG_THICKNESS_CM / 2.0
)
for y_sign, row_name in ((-1, "Front"), (1, "Rear")):
for x_sign, side_name in ((-1, "Left"), (1, "Right")):
add_box(
f"{row_name} {side_name} Leg",
(LEG_THICKNESS_CM, LEG_THICKNESS_CM, LEG_HEIGHT_CM),
(
x_sign * leg_x,
y_sign * leg_y,
LEG_HEIGHT_CM / 2.0
)
)
# Seat.
seat_top_cm = LEG_HEIGHT_CM + SEAT_THICKNESS_CM
add_box(
"Seat",
(SEAT_WIDTH_CM, SEAT_DEPTH_CM, SEAT_THICKNESS_CM),
(0.0, 0.0, LEG_HEIGHT_CM + SEAT_THICKNESS_CM / 2.0)
)
# Solid backrest, resting on the rear edge of the seat.
# Positive Y is the rear of the chair.
backrest_center_y_cm = (
SEAT_DEPTH_CM / 2.0 - BACKREST_THICKNESS_CM / 2.0
)
add_box(
"Backrest",
(
BACKREST_WIDTH_CM,
BACKREST_THICKNESS_CM,
BACKREST_HEIGHT_CM
),
(
0.0,
backrest_center_y_cm,
seat_top_cm + BACKREST_HEIGHT_CM / 2.0
)
)
# Select the finished chair.
bpy.ops.object.select_all(action='DESELECT')
for obj in chair_collection.objects:
obj.select_set(True)
print("Wooden chair created in the 'Wooden Chair' collection.")Use a visualização Material Preview ou Rendered para ver os veios da madeira procedural.
Uma empresa de SaaS tem US$ 4,2 milhões de ARR, churn anual de 18%, custo de aquisição de cliente de US$ 1.900 e contrato médio de US$ 6.000 por ano com margem bruta de 78%. Calcule o LTV, a relação LTV/CAC e o payback do CAC em meses, depois diga em duas frases se vale gastar mais em crescimento.
Supondo churn constante e sem receita de expansão nem descontos:
- Lucro bruto anual por cliente: US$ 6.000 × 78% = US$ 4.680
- LTV: US$ 4.680 ÷ 18% = US$ 26.000 (vida média implícita do cliente: 5,56 anos)
- LTV para CAC: US$ 26.000 ÷ US$ 1.900 = 13,7×
- Payback do CAC: US$ 1.900 ÷ (US$ 4.680 ÷ 12) = 4,9 meses
Sim: esses números sustentam com folga gastar mais em crescimento, desde que o CAC esteja totalmente carregado e os números de churn e margem sejam confiáveis. Aumente o investimento aos poucos, acompanhando o CAC marginal, a retenção e o caixa, porque o desempenho com mais investimento pode ser diferente dessas médias históricas.
Escreva um único arquivo HTML com Three.js que mostre uma ilha low-poly com um farol cujo feixe de luz gira devagar, ondas suaves na água e controles de órbita. Até 150 linhas.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Low-Poly Lighthouse Island</title>
<style>
html, body { margin: 0; height: 100%; overflow: hidden; }
canvas { display: block; }
</style>
<script type="importmap">
{
"imports": {
"three": "https://cdn.jsdelivr.net/npm/three@0.160.0/build/three.module.js",
"three/addons/": "https://cdn.jsdelivr.net/npm/three@0.160.0/examples/jsm/"
}
}
</script>
</head>
<body>
<script type="module">
import * as THREE from 'three';
import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
const scene = new THREE.Scene();
scene.background = new THREE.Color(0xa7d5df);
scene.fog = new THREE.Fog(0xa7d5df, 45, 105);
const camera = new THREE.PerspectiveCamera(50, innerWidth / innerHeight, 0.1, 200);
camera.position.set(18, 14, 23);
const renderer = new THREE.WebGLRenderer({ antialias: true });
renderer.setSize(innerWidth, innerHeight);
renderer.setPixelRatio(Math.min(devicePixelRatio, 2));
renderer.toneMapping = THREE.ACESFilmicToneMapping;
document.body.appendChild(renderer.domElement);
const controls = new OrbitControls(camera, renderer.domElement);
controls.target.set(0, 4, 0);
controls.enableDamping = true;
controls.minDistance = 10;
controls.maxDistance = 60;
controls.maxPolarAngle = Math.PI / 2.05;
controls.update();
scene.add(new THREE.HemisphereLight(0xe8fbff, 0x415b50, 2));
const sun = new THREE.DirectionalLight(0xfff0cf, 2.6);
sun.position.set(-12, 20, 10);
scene.add(sun);
const mat = (color, options = {}) => new THREE.MeshStandardMaterial({
color, roughness: 0.85, flatShading: true, ...options
});
function add(geometry, material, parent = scene) {
const object = new THREE.Mesh(geometry, material);
parent.add(object);
return object;
}
// Faceted island and grassy top.
const island = add(new THREE.CylinderGeometry(6.3, 8.5, 3, 9), mat(0x8b7355));
island.position.y = 0.35;
const grass = add(new THREE.CylinderGeometry(6.3, 6.5, 0.55, 9), mat(0x64834d));
grass.position.y = 2;
const rockMat = mat(0x6c7161);
for (let i = 0; i < 6; i++) {
const angle = i * 1.07 + 0.4, radius = 4.8 + (i % 2) * 0.5;
const rock = add(new THREE.DodecahedronGeometry(0.35 + (i % 3) * 0.12), rockMat);
rock.position.set(Math.cos(angle) * radius, 2.35, Math.sin(angle) * radius);
rock.scale.y = 0.65;
}
// Lighthouse built from alternating tapered stripes.
const house = new THREE.Group();
house.position.y = 2.28;
scene.add(house);
const white = mat(0xf4eee0), red = mat(0xc94b42), dark = mat(0x33434a);
const base = add(new THREE.CylinderGeometry(1.25, 1.4, 0.35, 12), dark, house);
base.position.y = 0.175;
for (let i = 0; i < 5; i++) {
const height = 1.05, bottom = 1 - i * 0.06;
const stripe = add(
new THREE.CylinderGeometry(bottom - 0.06, bottom, height, 12),
i % 2 ? red : white, house
);
stripe.position.y = 0.35 + height * (i + 0.5);
}
const door = add(new THREE.BoxGeometry(0.42, 0.75, 0.08), dark, house);
door.position.set(0, 0.72, 1);
const deck = add(new THREE.CylinderGeometry(1.15, 1.15, 0.18, 12), dark, house);
deck.position.y = 5.68;
const glass = add(new THREE.CylinderGeometry(0.68, 0.68, 1.05, 8),
mat(0x9ed7dd, { transparent: true, opacity: 0.45, roughness: 0.15 }), house);
glass.position.y = 6.3;
const roof = add(new THREE.ConeGeometry(1.05, 0.7, 8), red, house);
roof.position.y = 7.18;
const bulb = add(new THREE.SphereGeometry(0.22, 8, 6),
new THREE.MeshBasicMaterial({ color: 0xfff3a6 }), house);
bulb.position.y = 6.3;
const glow = new THREE.PointLight(0xffd978, 18, 15);
glow.position.y = 6.3;
house.add(glow);
// A translucent cone with its apex at the lamp.
const beamPivot = new THREE.Group();
beamPivot.position.y = 6.3;
house.add(beamPivot);
const beamGeometry = new THREE.ConeGeometry(2.8, 14, 24, 1, true);
beamGeometry.translate(0, -7, 0);
const beam = add(beamGeometry, new THREE.MeshBasicMaterial({
color: 0xfff2a0, transparent: true, opacity: 0.16,
side: THREE.DoubleSide, depthWrite: false, blending: THREE.AdditiveBlending
}), beamPivot);
beam.rotation.z = Math.PI / 2;
const waterGeometry = new THREE.PlaneGeometry(140, 140, 44, 44);
waterGeometry.rotateX(-Math.PI / 2);
const water = new THREE.Mesh(waterGeometry, new THREE.MeshPhongMaterial({
color: 0x187f96, specular: 0x9edce6, shininess: 70,
flatShading: true, transparent: true, opacity: 0.96
}));
scene.add(water);
const clock = new THREE.Clock();
function animate() {
requestAnimationFrame(animate);
const t = clock.getElapsedTime();
beamPivot.rotation.y = t * 0.28;
const positions = waterGeometry.attributes.position;
for (let i = 0; i < positions.count; i++) {
const x = positions.getX(i), z = positions.getZ(i);
positions.setY(i, Math.sin(x * 0.45 + t * 1.2) * 0.09
+ Math.cos(z * 0.38 + t) * 0.07);
}
positions.needsUpdate = true;
waterGeometry.computeVertexNormals();
controls.update();
renderer.render(scene, camera);
}
animate();
addEventListener('resize', () => {
camera.aspect = innerWidth / innerHeight;
camera.updateProjectionMatrix();
renderer.setSize(innerWidth, innerHeight);
});
</script>
</body>
</html>Mais prompts para testar com o Kimi K3.1 Pro
Kimi K3.1 Pro vs outros modelos
Os mesmos testes em todos os modelos, além de contexto, saída e velocidade, um rival de cada vez.
| Característica | Kimi K3.1 Pro | Claude Opus 5.5 |
|---|---|---|
| Desenvolvedor | Moonshot AI | Anthropic |
| Lançamento | 23 out. 2026 | 22 set. 2026 |
| Janela de contexto? | 1M tokens | 1M tokens |
| Saída máxima? | Até 1M tokens | 128K tokens |
| Velocidade? | 74 tokens/s | 96 tokens/s |
| Entrada | Texto, imagens, vídeo | Texto, imagens, arquivos |
| Característica | Kimi K3.1 Pro | GPT-6 Astra |
|---|---|---|
| Desenvolvedor | Moonshot AI | OpenAI |
| Lançamento | 23 out. 2026 | 3 set. 2026 |
| Janela de contexto? | 1M tokens | 1M tokens |
| Saída máxima? | Até 1M tokens | 128K tokens |
| Velocidade? | 74 tokens/s | 58 tokens/s |
| Entrada | Texto, imagens, vídeo | Texto, imagens, arquivos |
| Característica | Kimi K3.1 Pro | Gemini 4 Argon |
|---|---|---|
| Desenvolvedor | Moonshot AI | |
| Lançamento | 23 out. 2026 | 30 set. 2026 |
| Janela de contexto? | 1M tokens | 1M tokens |
| Saída máxima? | Até 1M tokens | 1M tokens |
| Velocidade? | 74 tokens/s | 79 tokens/s |
| Entrada | Texto, imagens, vídeo | Texto, imagens, áudio, vídeo, arquivos |
| Característica | Kimi K3.1 Pro | DeepSeek V4.1 Flash |
|---|---|---|
| Desenvolvedor | Moonshot AI | DeepSeek |
| Lançamento | 23 out. 2026 | 17 out. 2026 |
| Janela de contexto? | 1M tokens | 1M tokens |
| Saída máxima? | Até 1M tokens | 384K tokens |
| Velocidade? | 74 tokens/s | 195 tokens/s |
| Entrada | Texto, imagens, vídeo | Texto, imagens |
| Característica | Kimi K3.1 Pro | Qwen3.8 Max |
|---|---|---|
| Desenvolvedor | Moonshot AI | Alibaba |
| Lançamento | 23 out. 2026 | 2 set. 2026 |
| Janela de contexto? | 1M tokens | 1M tokens |
| Saída máxima? | Até 1M tokens | 131K tokens |
| Velocidade? | 74 tokens/s | 42 tokens/s |
| Entrada | Texto, imagens, vídeo | Texto, imagens, vídeo |
| Característica | Kimi K3.1 Pro | GLM 5.3 |
|---|---|---|
| Desenvolvedor | Moonshot AI | Z.ai |
| Lançamento | 23 out. 2026 | 18 ago. 2026 |
| Janela de contexto? | 1M tokens | 1M tokens |
| Saída máxima? | Até 1M tokens | 128K tokens |
| Velocidade? | 74 tokens/s | 85 tokens/s |
| Entrada | Texto, imagens, vídeo | Texto |
Principais recursos do Kimi K3.1 Pro
Tarefas longas de programação, scripts 3D e CAD, pesquisa e arquivos de escritório, imagens e vídeo em um contexto de 1M de tokens.
Programação de longo prazo
O Kimi K3.1 Pro conduz tarefas longas de programação com pouca supervisão: planeja a mudança, edita arquivos em todo o projeto, roda os testes e corrige o que falha. No Terminal-Bench 4.0, um teste de tarefas de programação que um agente conclui no terminal, ele marca 67,2% nos testes da Artificial Analysis, o melhor resultado entre todos os modelos que eles testaram. No SWE Marathon da Moonshot, um teste de tarefas longas de software, ele marca 51,7%, à frente do Claude Opus 5.5 e do GPT-6 Astra.
Código para 3D, CAD e jogos
A Moonshot treinou o K3.1 Pro em engines de jogos e ferramentas 3D. Ele escreve código para Unity, Unreal Engine, Godot e Three.js e scripts que criam modelos no Blender e no FreeCAD sem plugins extras. Descreva o objeto e passe as medidas, e ele devolve um script que você roda do jeito que está. No BenchCAD, um teste de criar modelos CAD a partir de descrições, ele marca 92,7% com ferramentas.
Pesquisa, finanças e arquivos de escritório
Envie uma planilha, um relatório ou uma apresentação e pergunte o que mudou e por quê. O K3.1 Pro lê tabelas e documentos longos, faz as contas e aponta a causa, não só os totais. Ele lidera a comparação da Moonshot no OfficeQA Pro v2, um teste de perguntas sobre documentos reais de escritório, com 64,4%, e no GDPval-AA, que avalia tarefas reais de trabalho de 44 profissões, chega a 1.846 de Elo, o terceiro entre todos os modelos testados pela Artificial Analysis.
Imagens, vídeo e 1M de tokens de contexto
O K3.1 Pro entende imagens e vídeo além de texto: prints, gráficos, páginas digitalizadas e gravações. A janela de contexto comporta 1 milhão de tokens, cerca de 750 mil palavras, então uma gravação longa, um plano de 60 páginas e todo o chat cabem de uma vez. No AA-LCR, um teste de perguntas espalhadas por documentos muito longos, ele marca 86,3%, à frente do Claude Opus 5.5 e do GPT-6 Astra.
Por que usar o Kimi K3.1 Pro na Overchat AI
Uma conta para chat, imagens e vídeo, em todos os dispositivos.
Agente de IA Superchat
O Superchat Agent envia sua mensagem automaticamente para o modelo mais adequado à tarefa. Ele gera imagens e vídeos, usa as ferramentas de IA da Overchat AI e aprende com suas interações para melhorar com o tempo.
Converse com imagens e arquivos
Envie PDFs, planilhas, código e imagens e pergunte ao Kimi K3.1 Pro sobre eles. Você também pode ditar a mensagem em vez de digitar.
Vá além do texto
Gere imagens com Nano Banana e GPT Image e vídeos com Seedance e Kling na mesma conta, com os mesmos créditos do chat.
Na web, no iPhone e no Android
Comece um chat no notebook e termine no celular. O app da Overchat AI tem os mesmos modelos, e seus chats ficam em uma única conta em todos os dispositivos.
Como usar o Kimi K3.1 Pro na Overchat AI
Comece no chat do topo desta página ou no app da Overchat AI na web, no iOS ou no Android.
- 1
Escolha o Kimi K3.1 Pro
Ele já vem selecionado no chat desta página. No app da Overchat AI, abra a lista de modelos ao lado do campo de mensagem e escolha o Kimi K3.1 Pro.
- 2
Anexe arquivos e descreva a tarefa
Adicione um relatório, uma planilha, código ou um print e escreva o que você precisa: o formato, o tamanho e o que verificar primeiro.
- 3
Continue no mesmo chat
Faça uma pergunta de acompanhamento, peça uma tabela ou uma versão mais curta, ou troque para outro modelo sem perder a conversa.
Conheça outros modelos
Todos os modelos abaixo estão no mesmo chat da Overchat AI que o Kimi K3.1 Pro.
Saiba mais sobre modelos de IA
Testamos o Gemini 4 Argon contra Claude Opus 5.5, GPT-6 Astra e Muse Wonder
Testamos o Gemini 4 Argon contra Claude Opus 5.5, GPT-6 Astra e Muse Wonder em três tarefas de programação. Veja benchmarks, velocidade e como usar.
Muse Wonder vs Muse Spark: testamos o novo modelo da Meta
Comparamos o Muse Wonder e o Muse Spark 1.3 em lógica, escrita e programação. Veja benchmarks e qual modelo da Meta é melhor.
10 melhores plataformas de IA tudo-em-um em 2026: por que uma assinatura de IA vale mais que várias
Compare as 10 melhores plataformas de IA tudo-em-um em 2026: preços, planos gratuitos e os modelos mais recentes, do Overchat AI ao Poe e ao Krater.
Perguntas frequentes sobre o Kimi K3.1 Pro
Se tiver qualquer dúvida,
fale com a gente em hello@overchat.ai
O Kimi K3.1 Pro é o modelo principal da Moonshot AI, lançado em 23 de outubro de 2026. É um modelo mixture-of-experts com 2,8 trilhões de parâmetros, 104 bilhões deles ativos por token, e janela de contexto de 1 milhão de tokens. Ele lê texto, imagens e vídeo e foi feito para tarefas longas de programação, scripts 3D e CAD, pesquisa e trabalho com documentos.
A Moonshot AI lançou o Kimi K3.1 Pro em 23 de outubro de 2026, junto com o Kimi K3.1 Pro Highspeed. É o primeiro modelo da série K3.1.
É o mesmo modelo base do Kimi K3, treinado com muito mais aprendizado por reforço. Na Artificial Analysis, o Intelligence Index subiu de 43,6 para 55,1 e o Terminal-Bench 4.0 de 12,6% para 67,2%. A Moonshot também informa que ele erra bem menos fatos: 8,3% no seu teste difícil de alucinação, contra 23,4% do Kimi K3.
Depende da tarefa. Na Artificial Analysis, o Claude Opus 5.5 tem o Intelligence Index geral mais alto (57,6 contra 55,1) e se sai melhor no Humanity's Last Exam. O Kimi K3.1 Pro fica à frente no Terminal-Bench 4.0 (67,2% contra 59,6%) e no AA-LCR, um teste com documentos longos (86,3% contra 84,7%).
Ainda não. A Moonshot diz que vai liberar os pesos completos até 4 de novembro de 2026, e a licença não foi anunciada. O Kimi K3, o modelo base, foi lançado com pesos abertos sob uma licença MIT modificada.
O Kimi K3.1 Pro aceita até 1.048.576 tokens de contexto, cerca de 750 mil palavras. As respostas têm até 131.072 tokens por padrão e podem chegar a 1 milhão de tokens.
Sim. Ele lê imagens e vídeo de forma nativa, incluindo prints, gráficos e páginas digitalizadas. PDFs e arquivos do Office são lidos como texto extraído. Na Overchat AI você pode anexar imagens e documentos à mensagem.
Não. O Kimi K3.1 Pro sempre pensa antes de responder. Pela API dá para reduzir o esforço de raciocínio para low, high ou max, trocando profundidade por velocidade.
O Kimi K3.1 Pro Highspeed é o mesmo modelo servido mais rápido: a Moonshot fala em duas a três vezes a velocidade da versão padrão, e a Artificial Analysis mediu cerca de 1,8 vez. Pela API da Moonshot ele custa o dobro por token.
Digite sua mensagem no chat do topo desta página, anexe arquivos se precisar e toque em Enviar. Depois de entrar, o Kimi K3.1 Pro responde no chat da Overchat AI, onde você pode continuar a conversa na web, no iOS ou no Android e trocar de modelo quando quiser.
