Crear Memoria

POST /memories

Crea una nueva memoria para el usuario autenticado.

Ejemplos de Código

cURL

curl --request POST \
  --url 'https://api.tess.im/memories' \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "content": "Este es un ejemplo de memoria",
    "metadata": {
      "source": "user_input",
      "tags": ["ejemplo", "prueba"]
    }
  }'

Node.js

const axios = require('axios');

const data = {
  content: 'Este es un ejemplo de memoria',
  metadata: {
    source: 'user_input',
    tags: ['ejemplo', 'prueba']
  }
};

const config = {
  method: 'post',
  url: 'https://api.tess.im/memories',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  data: data
};

try {
  const response = await axios(config);
  console.log(response.data);
} catch (error) {
  console.error(error);
}

Python

import requests
import json

url = "https://api.tess.im/memories"
headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json"
}
data = {
    "content": "Este es un ejemplo de memoria",
    "metadata": {
        "source": "user_input",
        "tags": ["ejemplo", "prueba"]
    }
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

PHP

<?php
$curl = curl_init();

$data = [
    "content" => "Este es un ejemplo de memoria",
    "metadata" => [
        "source" => "user_input",
        "tags" => ["ejemplo", "prueba"]
    ]
];

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.tess.im/memories",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode($data),
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer YOUR_API_KEY",
    "Content-Type: application/json"
  ]
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "Error: " . $err;
} else {
  echo $response;
}

Java

import com.fasterxml.jackson.databind.ObjectMapper;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.Map;

public class Main {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();

        Map<String, Object> metadata = Map.of(
            "source", "user_input",
            "tags", java.util.List.of("ejemplo", "prueba")
        );

        Map<String, Object> data = Map.of(
            "content", "Este es un ejemplo de memoria",
            "metadata", metadata
        );

        String jsonPayload = mapper.writeValueAsString(data);

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.tess.im/memories"))
            .header("Authorization", "Bearer YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

Go

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

type MemoryData struct {
    Content  string                 `json:"content"`
    Metadata map[string]interface{} `json:"metadata"`
}

func main() {
    data := MemoryData{
        Content: "Este es un ejemplo de memoria",
        Metadata: map[string]interface{}{
            "source": "user_input",
            "tags": []string{"ejemplo", "prueba"},
        },
    }

    jsonData, err := json.Marshal(data)
    if err != nil {
        fmt.Println(err)
        return
    }

    client := &http.Client{}
    req, err := http.NewRequest("POST", "https://api.tess.im/memories", bytes.NewBuffer(jsonData))
    if err != nil {
        fmt.Println(err)
        return
    }

    req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
    req.Header.Add("Content-Type", "application/json")

    resp, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(string(body))
}

.NET

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using System.Collections.Generic;

class Program
{
    static async Task Main(string[] args)
    {
        using (var client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");

            var metadata = new Dictionary<string, object>
            {
                { "source", "user_input" },
                { "tags", new List<string> { "ejemplo", "prueba" } }
            };

            var data = new
            {
                content = "Este es un ejemplo de memoria",
                metadata = metadata
            };

            var jsonPayload = JsonConvert.SerializeObject(data);
            var content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");

            try
            {
                var response = await client.PostAsync("https://api.tess.im/memories", content);
                response.EnsureSuccessStatusCode();
                string responseBody = await response.Content.ReadAsStringAsync();
                Console.WriteLine(responseBody);
            }
            catch (HttpRequestException e)
            {
                Console.WriteLine("\nException Caught!");
                Console.WriteLine("Message :{0} ", e.Message);
            }
        }
    }
}

Ruby

require 'uri'
require 'net/http'
require 'json'

uri = URI('https://api.tess.im/memories')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['Content-Type'] = 'application/json'
request.body = {
    "content": "Este es un ejemplo de memoria",
    "metadata": {
        "source": "user_input",
        "tags": ["ejemplo", "prueba"]
    }
}.to_json

response = http.request(request)
puts response.read_body

Encabezados

Parámetro	Tipo	Requerido	Descripción
x-workspace-id	integer	No	ID del espacio de trabajo. Si no se proporciona, se utilizará el espacio de trabajo seleccionado del usuario.

Nota: Este campo será requerido en una futura versión de la API. Se recomienda encarecidamente configurarlo ahora para asegurar la compatibilidad con futuras actualizaciones.

Parámetros del Cuerpo

Parámetro	Tipo	Requerido	Descripción
content	string	Sí	El contenido de la memoria
metadata	object	No	Metadatos asociados a la memoria

Respuesta

{
"id": 123,
"content": "Este es un ejemplo de memoria",
"metadata": {
  "source": "user_input",
  "tags": ["ejemplo", "prueba"]
},
"created_at": "2025-01-05T22:39:57+00:00",
"updated_at": "2025-01-05T22:39:57+00:00"
}

¡Pruébalo!

Autenticación

Este endpoint requiere autenticación con token Bearer.

Probar Endpoint

Cuerpo de la Solicitud