Creación de un flujo de trabajo de cifrado seguro y habilitado para la memoria para agentes de IA con selección e integración de API Dynamic LLM

En este tutorial, caminamos a través de la construcción de un compacto pero completamente funcional Cifrar-La de trabajo basado en el flujo de trabajo. Comenzamos capturando de forma segura nuestra clave de la API de Géminis en la interfaz de usuario de Colab sin exponerla en código. Luego implementamos una función de selección dinámica de LLM que puede cambiar automáticamente entre Operai, Gemini o Anthrope en función de qué tecla API está disponible. La fase de configuración asegura que se instalen Node.js y la CLI cifrado, después de lo cual generamos programáticamente una configuración CIPHER.YML para habilitar un agente de memoria con un retiro a largo plazo. Creamos funciones auxiliares para ejecutar comandos de cifrado directamente desde Python, almacenar decisiones clave del proyecto como recuerdos persistentes, recuperarlas a pedido y finalmente girar el cifrado en el modo API para la integración externa. Mira el Códigos completos aquí.

import os, getpass
os.environ["GEMINI_API_KEY"] = getpass.getpass("Enter your Gemini API key: ").strip()


import subprocess, tempfile, pathlib, textwrap, time, requests, shlex


def choose_llm():
   if os.getenv("OPENAI_API_KEY"):
       return "openai", "gpt-4o-mini", "OPENAI_API_KEY"
   if os.getenv("GEMINI_API_KEY"):
       return "gemini", "gemini-2.5-flash", "GEMINI_API_KEY"
   if os.getenv("ANTHROPIC_API_KEY"):
       return "anthropic", "claude-3-5-haiku-20241022", "ANTHROPIC_API_KEY"
   raise RuntimeError("Set one API key before running.")

Comenzamos ingresando de forma segura nuestra tecla API Gemini usando GetPass para que permanezca oculto en la interfaz de usuario de Colab. Luego definimos una función ChoPE_LLM () que verifica nuestras variables de entorno y selecciona automáticamente el proveedor, modelo y clave LLM apropiado en función de lo que está disponible. Mira el Códigos completos aquí.

def run(cmd, check=True, env=None):
   print("▸", cmd)
   p = subprocess.run(cmd, shell=True, text=True, capture_output=True, env=env)
   if p.stdout: print(p.stdout)
   if p.stderr: print(p.stderr)
   if check and p.returncode != 0:
       raise RuntimeError(f"Command failed: {cmd}")
   return p

Creamos una función Run () auxiliar que ejecuta los comandos de shell, imprime STDOUT y STDERR para la visibilidad, y plantea un error si el comando falla cuando la comprobación está habilitada, lo que hace que nuestra ejecución del flujo de trabajo sea más transparente y confiable. Mira el Códigos completos aquí.

def ensure_node_and_cipher():
   run("sudo apt-get update -y && sudo apt-get install -y nodejs npm", check=False)
   run("npm install -g @byterover/cipher")

Definimos asegurar_node_and_cipher () para instalar Node.js, NPM y la CLI de cifrado a nivel mundial, asegurando que nuestro entorno tenga todas las dependencias necesarias antes de ejecutar cualquier comando relacionado con el cifrado. Mira el Códigos completos aquí.

def write_cipher_yml(workdir, provider, model, key_env):
   cfg = """
llm:
 provider: {provider}
 model: {model}
 apiKey: ${key_env}
systemPrompt:
 enabled: true
 content: |
   You are an AI programming assistant with long-term memory of prior decisions.
embedding:
 disabled: true
mcpServers:
 filesystem:
   type: stdio
   command: npx
   args: ['-y','@modelcontextprotocol/server-filesystem','.']
""".format(provider=provider, model=model, key_env=key_env)


   (workdir / "memAgent").mkdir(parents=True, exist_ok=True)
   (workdir / "memAgent" / "cipher.yml").write_text(cfg.strip() + "n")

Implementamos write_cipher_yml () para generar un archivo de configuración cipher.yml dentro de una carpeta memagente, configurar el proveedor LLM elegido, el modelo y la tecla API, habilitando una solicitud del sistema con memoria a largo plazo y registrar un sistema de archivos MCP servidor Para operaciones de archivo. Mira el Códigos completos aquí.

def cipher_once(text, env=None, cwd=None):
   cmd = f'cipher {shlex.quote(text)}'
   p = subprocess.run(cmd, shell=True, text=True, capture_output=True, env=env, cwd=cwd)
   print("Cipher says:n", p.stdout or p.stderr)
   return p.stdout.strip() or p.stderr.strip()

Definimos cipher_once () para ejecutar un solo comando CIPER CIPHER con el texto proporcionado, capturar y mostrar su salida, y devolver la respuesta, lo que nos permite interactuar con cifrado programáticamente desde Python. Mira el Códigos completos aquí.

def start_api(env, cwd):
   proc = subprocess.Popen("cipher --mode api", shell=True, env=env, cwd=cwd,
                           stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
   for _ in range(30):
       try:
           r = requests.get("http://127.0.0.1:3000/health", timeout=2)
           if r.ok:
               print("API /health:", r.text)
               break
       except: pass
       time.sleep(1)
   return proc

Creamos Start_api () para iniciar cifras en el modo API como subprocesos, luego sonó repetidamente su punto final /salud hasta que responde, asegurando que el servidor API esté listo antes de continuar. Mira el Códigos completos aquí.

def main():
   provider, model, key_env = choose_llm()
   ensure_node_and_cipher()
   workdir = pathlib.Path(tempfile.mkdtemp(prefix="cipher_demo_"))
   write_cipher_yml(workdir, provider, model, key_env)
   env = os.environ.copy()


   cipher_once("Store decision: use pydantic for config validation; pytest fixtures for testing.", env, str(workdir))
   cipher_once("Remember: follow conventional commits; enforce black + isort in CI.", env, str(workdir))


   cipher_once("What did we standardize for config validation and Python formatting?", env, str(workdir))


   api_proc = start_api(env, str(workdir))
   time.sleep(3)
   api_proc.terminate()


if __name__ == "__main__":
   main()

En Main (), seleccionamos el proveedor de LLM, instalamos dependencias y creamos un directorio de trabajo temporal con una configuración CIPHER.YML. Luego almacenamos decisiones clave del proyecto en la memoria de Cipher, las consultamos y finalmente iniciamos el servidor API de cifrado brevemente antes de cerrarla, demostrando interacciones basadas en CLI y API.

En conclusión, tenemos un entorno de cifrado que administra de forma segura las teclas API, selecciona el proveedor LLM correcto automáticamente y configura un agente habilitado para la memoria por completo a través de la automatización de Python. Nuestra implementación incluye registro de decisiones, recuperación de memoria y un punto final de API en vivo, todo orquestado en un flujo de trabajo amigable con el cuaderno/colab. Esto hace que la configuración sea reutilizable para otras tuberías de desarrollo asistidas por AI-AI, lo que nos permite almacenar y consultar el conocimiento del proyecto mediante programación mientras mantiene el entorno liviano y fácil de volver a desplegar.

Mira el Códigos completos aquí. No dude en ver nuestro Página de Github para tutoriales, códigos y cuadernos. Además, siéntete libre de seguirnos Gorjeo Y no olvides unirte a nuestro Subreddit de 100k+ ml y suscribirse a Nuestro boletín.

Asif Razzaq es el CEO de MarktechPost Media Inc .. Como empresario e ingeniero visionario, ASIF se compromete a aprovechar el potencial de la inteligencia artificial para el bien social. Su esfuerzo más reciente es el lanzamiento de una plataforma de medios de inteligencia artificial, MarktechPost, que se destaca por su cobertura profunda de noticias de aprendizaje automático y de aprendizaje profundo que es técnicamente sólido y fácilmente comprensible por una audiencia amplia. La plataforma cuenta con más de 2 millones de vistas mensuales, ilustrando su popularidad entre el público.