Actualizar Memoria

PUT /memories/{id}

Actualiza una memoria existente por su ID.

Ejemplos de Código

cURL

curl --request PUT \
  --url 'https://api.tess.im/memories/{id}' \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "content": "Contenido actualizado de la memoria",
    "metadata": {
      "source": "fuente_actualizada",
      "tags": ["actualizado", "prueba"]
    }
  }'

Node.js

const axios = require('axios');

const data = {
  content: 'Contenido actualizado de la memoria',
  metadata: {
    source: 'fuente_actualizada',
    tags: ['actualizado', 'prueba']
  }
};

const config = {
  method: 'put',
  url: 'https://api.tess.im/memories/{id}',
  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/{id}"
headers = {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json"
}
data = {
    "content": "Contenido actualizado de la memoria",
    "metadata": {
        "source": "fuente_actualizada",
        "tags": ["actualizado", "prueba"]
    }
}

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

PHP

<?php
$curl = curl_init();

$data = [
    "content" => "Contenido actualizado de la memoria",
    "metadata" => [
        "source" => "fuente_actualizada",
        "tags" => ["actualizado", "prueba"]
    ]
];

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.tess.im/memories/{id}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  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", "fuente_actualizada",
            "tags", java.util.List.of("actualizado", "prueba")
        );

        Map<String, Object> data = Map.of(
            "content", "Contenido actualizado de la memoria",
            "metadata", metadata
        );

        String jsonPayload = mapper.writeValueAsString(data);

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.tess.im/memories/{id}"))
            .header("Authorization", "Bearer YOUR_API_KEY")
            .header("Content-Type", "application/json")
            .PUT(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: "Contenido actualizado de la memoria",
        Metadata: map[string]interface{}{
            "source": "fuente_actualizada",
            "tags": []string{"actualizado", "prueba"},
        },
    }

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

    client := &http.Client{}
    req, err := http.NewRequest("PUT", "https://api.tess.im/memories/{id}", 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", "fuente_actualizada" },
                { "tags", new List<string> { "actualizado", "prueba" } }
            };

            var data = new
            {
                content = "Contenido actualizado de la memoria",
                metadata = metadata
            };

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

            try
            {
                var response = await client.PutAsync("https://api.tess.im/memories/{id}", 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/{id}')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Put.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['Content-Type'] = 'application/json'
request.body = {
    "content": "Contenido actualizado de la memoria",
    "metadata": {
        "source": "fuente_actualizada",
        "tags": ["actualizado", "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 de Ruta

Parámetro	Tipo	Requerido	Descripción
id	string	Sí	El ID de la memoria

Parámetros del Cuerpo

Parámetro	Tipo	Requerido	Descripción
content	string	No	El contenido actualizado de la memoria
metadata	object	No	Metadatos actualizados de la memoria

Respuesta

{
"id": 123,
"content": "Contenido actualizado de la memoria",
"metadata": {
  "source": "fuente_actualizada",
  "tags": ["actualizado", "prueba"]
},
"created_at": "2025-01-05T22:39:57+00:00",
"updated_at": "2025-01-05T22:40:00+00:00"
}

¡Pruébalo!

Autenticación

Este endpoint requiere autenticación con token Bearer.

Probar Endpoint

id

Cuerpo de la Solicitud