Para programadores
Integra-te com a REST API da Refine ou liga ferramentas de IA através do Model Context Protocol (MCP)
MCP
Model Context Protocol (MCP)
O MCP é uma norma aberta que permite que os assistentes de IA interajam diretamente com ferramentas externas e fontes de dados. Liga a tua ferramenta de IA preferida à Refine através de um único endpoint.
- Adiciona o URL do endpoint MCP da Refine à configuração da tua ferramenta de IA
- A tua ferramenta tratará automaticamente da autenticação OAuth
Usas o Claude na web, no computador ou no telemóvel? Instala o conector da Refine diretamente do diretório do Claude, sem teres de colar qualquer configuração.
Abre o conector da Refine{
"mcpServers": {
"refine": {
"url": "https://api.refine.ink/mcp"
}
}
}{
"mcpServers": {
"refine": {
"url": "https://api.refine.ink/mcp"
}
}
}{
"servers": {
"refine": {
"type": "http",
"url": "https://api.refine.ink/mcp"
}
}
}O OAuth é o método de autenticação predefinido. O teu cliente MCP tratará automaticamente do fluxo de autorização.
O MCP também pode usar chaves de API para autenticação.
REST API
REST API
Uma REST API com documentação OpenAPI interativa. Explora todos os endpoints disponíveis, os esquemas de pedidos e respostas e experimenta pedidos diretamente no navegador.
Explorar documentação da API- Cria uma chave de API em Definições avançadas da conta, na tua página de perfil
- Usa a chave para autenticar os teus pedidos
# 1. Upload a document
UPLOAD=$(curl -s -X POST "https://api.refine.ink/documents/upload" \
-H "X-API-Key: your-api-key" \
-F "file=@paper.pdf")
TASK_ID=$(echo $UPLOAD | jq -r '.task_id')
# 2. Wait for upload processing via SSE
curl -N "https://api.refine.ink/documents/upload/events/$TASK_ID?token=your-api-key"
# Listen until you receive: event: complete, data: {"document_id": "..."}
DOCUMENT_ID="<document_id from SSE>"
# 3. Start document processing (costs 1 credit)
PROCESS=$(curl -s -X POST "https://api.refine.ink/documents/$DOCUMENT_ID/process" \
-H "X-API-Key: your-api-key" \
-H "Content-Type: application/json" \
-d '{"preview": false}')
SESSION_ID=$(echo $PROCESS | jq -r '.session_id')
# 4. Stream processing progress via SSE
curl -N "https://api.refine.ink/documents/$DOCUMENT_ID/process/events/$SESSION_ID?token=your-api-key"import requests
import sseclient # pip install sseclient-py
API_KEY = "your-api-key"
BASE = "https://api.refine.ink"
headers = {"X-API-Key": API_KEY}
# 1. Upload a document
with open("paper.pdf", "rb") as f:
upload = requests.post(
f"{BASE}/documents/upload",
headers=headers,
files={"file": f}
).json()
task_id = upload["task_id"]
# 2. Wait for upload processing via SSE
response = requests.get(
f"{BASE}/documents/upload/events/{task_id}?token={API_KEY}",
stream=True
)
client = sseclient.SSEClient(response)
for event in client.events():
if event.event == "complete":
document_id = json.loads(event.data)["document_id"]
break
# 3. Start document processing (costs 1 credit)
process = requests.post(
f"{BASE}/documents/{document_id}/process",
headers=headers,
json={"preview": False}
).json()
session_id = process["session_id"]
# 4. Stream processing progress via SSE
response = requests.get(
f"{BASE}/documents/{document_id}/process/events/{session_id}?token={API_KEY}",
stream=True
)
for event in sseclient.SSEClient(response).events():
print(event.event, event.data)const API_KEY = "your-api-key";
const BASE = "https://api.refine.ink";
// 1. Upload a document
const form = new FormData();
form.append("file", new Blob([fileBuffer]), "paper.pdf");
const upload = await fetch(`${BASE}/documents/upload`, {
method: "POST",
headers: { "X-API-Key": API_KEY },
body: form,
}).then(r => r.json());
const taskId = upload.task_id;
// 2. Wait for upload processing via SSE
const uploadEvents = new EventSource(
`${BASE}/documents/upload/events/${taskId}?token=${API_KEY}`
);
const documentId = await new Promise<string>((resolve) => {
uploadEvents.addEventListener("complete", (e) => {
resolve(JSON.parse(e.data).document_id);
uploadEvents.close();
});
});
// 3. Start document processing (costs 1 credit)
const process = await fetch(
`${BASE}/documents/${documentId}/process`,
{
method: "POST",
headers: {
"X-API-Key": API_KEY,
"Content-Type": "application/json",
},
body: JSON.stringify({ preview: false }),
}
).then(r => r.json());
// 4. Stream processing progress via SSE
const processEvents = new EventSource(
`${BASE}/documents/${documentId}/process/events/${process.session_id}?token=${API_KEY}`
);
// Events are named, so listen per event rather than on "message"
processEvents.addEventListener("progress", (e) => {
console.log(JSON.parse(e.data));
});
processEvents.addEventListener("complete", (e) => {
console.log(JSON.parse(e.data));
processEvents.close();
});Mantém as tuas chaves de API seguras. Não faças commit delas no controlo de versões nem as exponhas em código do lado do cliente.
Testes
Testa a tua integração
Não precisas de gastar créditos para desenvolver com a Refine. Cria um mock da API a partir do nosso esquema OpenAPI enquanto desenvolves a integração e, quando estiveres pronto, muda para o pipeline real.
Cria um mock da API a partir do esquema OpenAPI
Cada endpoint está descrito no nosso esquema OpenAPI, por isso qualquer ferramenta de mock que leia OpenAPI pode criar para ti uma API falsa da Refine — Prism, Mockoon, Microcks, WireMock, Postman ou o próprio servidor de mock da tua framework. Aponta o teu cliente para essa API para testares o teu código de carregamento, processamento e polling sem tocares no serviço real.
# Grab the OpenAPI schema
curl -o refine-openapi.json https://api.refine.ink/openapi.json
# Serve a mock from it with the tool of your choice, e.g. Prism
npx @stoplight/prism-cli mock refine-openapi.json
# Point your client at the mock instead of the real API
export REFINE_API_URL=http://127.0.0.1:4010O esquema está sempre sincronizado com a API em produção: ver o esquema OpenAPI.
Ou testa o fluxo real
Os mocks não te mostram como são os comentários reais. Contacta-nos e concederemos créditos de pré-visualização à tua conta, para poderes processar documentos reais no pipeline completo. As execuções de pré-visualização são passagens rápidas com pouco processamento, por isso devolvem menos comentários do que uma Revisão completa — o suficiente para validares a tua integração de ponta a ponta.
Contacta-nos para pedir créditos de pré-visualizaçãoComeça a desenvolver
As APIs para programadores estão em beta e agradecemos os teus comentários à medida que continuamos a desenvolvê-las.