Desenvolvedores

Imagens

Uma memória pode carregar uma imagem. O motor indexa a imagem, então uma consulta em texto em qualquer idioma a encontra mesmo quando o registro não tem legenda, título nem texto alternativo.

Compatível com o Tablet 2 e modelos mais novos. Um motor que não implementa imagens informa isso pelo nome em vez de responder um 404 seco, o que permite distinguir um recurso ausente de uma memória ausente. JPEG, PNG, GIF e WebP.

Armazenar uma

Passe um objeto image para a chamada comum de add. content pode ficar vazio; nesse caso a imagem é pesquisável sozinha.

   
mem.add("at the beach", image={"data": b64})   # caption + image
mem.add("", image={"data": b64})               # the image IS the memory
// the image rides in the 4th argument; the 3rd is metadata
await mem.add("at the beach", undefined, {}, { image: { data: b64 } });
await mem.add("", undefined, {}, { image: { data: b64 } });   // the image IS the memory
let img = json!({"image": {"data": b64}});
mem.add_with("at the beach", None, json!({}), img.clone()).await?;
mem.add_with("", None, json!({}), img).await?;
curl -X POST https://api.wontopos.com/api/v1/memory/store \
  -H "X-API-Key: $WOS_KEY" -H "Content-Type: application/json" \
  -d '{"user_id":"alice","content":"","image":{"data":"<base64>"}}'

data é obrigatório. O prefixo data:image/jpeg;base64, e as quebras de linha adicionadas por base64 e openssl são removidos para você.

Campo	O que faz
data	Base64 da imagem. Obrigatório. O teto de tamanho é uma configuração do servidor, não uma constante do SDK - `/health` o informa como `memory.images.max_bytes`.
reference	Onde fica a sua própria cópia do original. Armazenado como string e nunca acessado por nós - e é exatamente o lugar dela, já que o que guardamos está reduzido.
taken_at	RFC3339, normalmente vindo do EXIF. Preenche `event_date` quando esse campo está vazio, então a memória é ordenada por quando a imagem foi tirada, não por quando foi enviada.

Encontrar uma

Não existe uma busca separada para imagens. search e recall retornam imagens junto com texto, classificadas em conjunto.

Trabalhar com as que já existem

   
data, mime = mem.get_image(memory_id=mid)
page       = mem.list_images(limit=50)      # page["count"] = store total
mem.forget_image(memory_id=mid, preview=True)
const { bytes, contentType } = await mem.getImage(undefined, mid);
const page = await mem.listImages(undefined, { limit: 50 });
await mem.forgetImage(undefined, mid, { preview: true });
let (bytes, mime) = mem.get_image(None, mid).await?;
let page = mem.list_images(None, 50, None, None).await?;
mem.forget_image(None, mid, true).await?;
# the picture we hold — the one call on this plane that is not JSON
curl -X POST   .../api/v1/memory/image  -d '{"user_id":"alice","memory_id":"m_1"}'
curl -X POST   .../api/v1/memory/images -d '{"user_id":"alice","limit":50}'
curl -X DELETE .../api/v1/memory/image  -d '{"user_id":"alice","memory_id":"m_1","preview":true}'

Chamada	O que faz
get_image	A imagem que guardamos, como `(bytes, content_type)` - não necessariamente a que você enviou. Uma imagem cujo lado maior passava de 1.568 px foi guardada reduzida e recodificada para WebP, a menos que fosse JPEG, então um PNG volta como `image/webp`. O tipo é detectado a partir dos bytes, não do nome com que o upload foi enviado: dê nome ao arquivo com base em `content_type`. Uma memória sem imagem lança um erro em vez de retornar algo vazio.
list_images	Uma página, da mais recente para a mais antiga, mais `count` - o total do store, não o tamanho da página. A paginação é por cursor: devolva `next_before` e `next_skip_ids`. Os dois são necessários porque imagens podem compartilhar o mesmo timestamp.
forget_image	Remove a imagem e mantém o texto. Uma imagem armazenada sem legenda é a memória, então nesse caso a memória também é apagada.

Passe preview=True para forget_image para obter memory_kept sem alterar nada. iter_images pagina para você.

Quanto custa uma imagem

Uma imagem é cobrada em tokens, a mesma unidade do texto. Tokens = área em pixels / 556,7. Acima de 1.568 px no lado maior a contagem é feita a 1.568 px, então uma imagem de 2.500 px custa o mesmo que uma de 1.568 px.

Imagem	Contabilizada em	Tokens
700 × 700	as sent	881
1000 × 1000	as sent	1,797
1568 × 1568	as sent	4,417
1920 × 1080	1568 × 882	2,485
2500 × 1875	1568 × 1176	3,313
2500 × 2500	1568 × 1568	4,417

Teto: 4.417 tokens por imagem. Reservamos esse teto do seu saldo antes da chamada e cobramos depois o valor medido, que nunca é maior.

O que guardamos é a imagem na resolução de uma memória, não o seu original. Acima de 1.568 px no lado maior ela é reduzida para 1.568 px na entrada, e é essa imagem menor que é indexada, armazenada e devolvida. Reduzir exige recodificar, então formatos sem perda são gravados como WebP: um PNG de 2.500 px volta com 1.568 px como image/webp. JPEG continua JPEG e, abaixo de 1.568 px, os bytes não são tocados. (Se a recodificação deixasse o arquivo maior, mantemos os seus bytes como estavam.) Os dois lados ainda precisam ser ≥ 700 px e o lado maior ≤ 2.500 px, caso contrário a chamada é recusada com um 400 - abaixo de 700 px aplica-se um mínimo fixo, então uma imagem menor custa o mesmo para armazenar, e acima de 2.500 px não decodificamos o arquivo de forma alguma. Guarde a sua própria cópia, ou coloque a URL dela em reference, se precisar do arquivo em resolução total.

Quantas retornam

Padrão 1, máximo de 5 imagens por resposta. Cinco imagens ficam perto de 20.000 tokens.

Campo	O que faz
max_images	De 0 a 5. Imagens que uma única resposta pode carregar. Padrão 1. `0` retorna apenas texto. Fora do intervalo é recusado, não ajustado ao limite.

Uma legenda em inglês na imagem melhora as consultas em inglês e piora as consultas nos outros idiomas - 11,4 pontos de recall@5 em média em quatorze idiomas. Armazene imagens sem legenda se os seus usuários pesquisam em mais de um idioma.

Product

Models