La herramienta correcta para gestión de tareas

Cualquier equipo, se dedique a lo que se dedique, cuando lo componen varias personas hay un momento en que alguien debe pararse y decir, ¿estamos haciendo las cosas bien? ¿en el orden correcto? ¿dedicando el tiempo necesario a cada una? ¿tenemos controlado el trabajo o el trabajo nos controla a nosotros? Lo que antes eran reuniones y encargos sencillos se ha convertido en un sin fin de recordatorios de cosas que no se han hecho, se han hecho sin necesidad o se han hecho demasiado tarde o demasiado pronto. En este punto es cuando la elección de una buena herramienta de gestión de tareas se hace necesaria.

Si esperáis que os diga cual es la correcta para el desarrollo de software, bueno, pues os equivocáis, todavía no he encontrado la que sea perfecta, pero si que puedo ofreceros mi visión sobre lo que necesitaría tener esa herramienta y los intentos de encontrarla que he tenido durante estos casi 30 años en el oficio.

Primero lo primero, cuales son las necesidades que queremos cubrir con esta herramienta:

  • Queremos poder registrar el tiempo dedicado y estimado para cada tarea sin que nos quite tiempo de trabajo efectivo.
  • Necesitamos saber la prioridad de las distintas tareas y poder ordenarlas en el tiempo.
  • Necesitamos saber quien tiene que trabajar en una tarea y qué es lo que tiene que hacer en la misma
  • Necesitamos saber el estado de cada tarea y el grado de avance general de la tarea y del proyecto al que pertenece
  • Es preciso poder descomponer el trabajo en tareas más pequeñas que puedan ser abordadas por una sola persona o, en el caso de requerir múltiples participantes al mismo tiempo que esté controlado el tiempo dedicado por cada persona
  • Queremos que cada proyecto tenga una visión clara de las tareas en curso y las que están en distintos estados del workflow de desarrollo
  • Necesitamos que haya una trazabilidad completa de las tareas desde su creación hasta que esta se termina
  • Es imprescindible disponer de documentación y una forma de asociarla a las tareas, pero de manera más independiente ya que la documentación ha de permanecer más allá de la vida de la tarea
  • Se necesita una manera ágil de comunicación entre los distintos componentes del equipo y, posiblemente, con elementos fuera de los equipos de desarrollo (usuarios, QA, dirección) aunque no es imprescindible que esté ligado al mismo sistema si que se necesita una manera sencilla de referirse a las tareas externamente.
  • Es deseable poder implementar distintos ciclos de vida a distintos tipos de proyectos y no limitarse a uno solo.
  • Si se usa un sistema el directorio de usuarios debe estar en sincronía con el de la empresa y la autenticación deberá ser compatible con la existente.

Evidentemente cada organización, empresa o grupo puede tener más o menos necesidades, pero en la lista anterior creo que he incluido las principales. El objetivo final es saber qué trabajo queda por hacer, qué hacer primero, tener previsiones de cuando estará un cierto trabajo complejo y saber cómo se están aprovechando los recursos. Obviamente cuanto más sencillo sea el sistema y cuanto menos tiempo nos quite de las tareas reales más efectivo será.

Y, para que sirva de referencia os voy a contar mi historia con los distintos sistemas de gestión de tareas que he tenido el «honor» de probar.

En el 97 empecé a trabajar profesionalmente en esto de la informática después de haber terminado la carrera y haber obtenido toda la teoría necesaria sobre gestión de proyectos y haber hecho un curso de CEPADE sobre gestión de proyectos tecnológicos. En la empresa en la que entré se gestionaba todo con Microsoft Project, por suerte generalmente la planificación moría en el momento en que el proyecto empezaba. Lo único que se esperaba respetar eran los plazos y los entregables. El tiempo dedicado no se actualizaba nunca y solo se ampliaban los plazos o, si el cliente se ponía pegigero, se cambiaba el alcance y se eliminaban o añadían tareas sin demasiado control.

Microsoft desarrolló una especie de project on-line para que los usuarios que estuviesen participando en un proyecto pudiesen imputar las horas o indicar cuando se habían acabado las tareas. Ahora mismo no recuerdo el nombre del producto, lo que si recuerdo es que era tan dificil de instalar y hacer funcionar correctamente que lo usamos solo en un proyecto antes del olvidarlo completamente. Project se quedó para el papeleo y marcar las fechas esperadas y controlar, por tanto, el retraso de las tareas y del proyecto en general.

Seguí usando project (sin ningún online y con control mediante arcaicas hojas excel) hasta que evolucioné lo suficiente (y puse mi propia empresa) como para usar Linux como mi máquina principal… Mira por donde ahí no había forma de ejecutar el project y me las vehía y deseaba para generar los gantt de manera medianamente atractiva para presentársela a los clientes (si, ya era para mis propios clientes). Llegados a este punto descubrí una herramienta online que, aunque inicialmente no creada para ello, servía perfectamente para hacer seguimiento del tiempo dedicado a las tareas de un proyecto, se trataba de trac. Tal como contaba en su página (hoy casi abandonada)

Trac es un sistema wiki mejorado y de seguimiento de incidencias para proyectos de desarrollo de software. Trac utiliza un enfoque minimalista para la gestión de proyectos de software basados en la web.

trac era un sistema de tickets, con un wiki para la documentación y conexión con subversion para el control de código. Si a esto le unimos que permitía indicar el número de horas dedicadas a cada incidencia, ya teníamos una primera forma de controlar en tiempo real las tareas. El wiki no era perfecto y la búsqueda también podía mejorarse, pero cumplió muy bien con su cometido durante unos cuantos años. De hecho el problema sobrevino cuando dejaron de mantener el producto y ya teníamos muchos proyectos gestionados con este sistema. Tengo que decir que antes de llegar a trac (que inicialmente se llamó svntrac) estuvimos usando cvstrac y cvs en lugar de subversion… Y si, tuvimos que migrar de cvs a subversion y de eso a git (es lo que tiene llevar más de 20 años produciendo código sin querer perder nada).

El caso es que descubrimos un poco después que había un programa que tenía todo lo que tenía trac (y algunas cosas más) que era completamente software libre y, además, rapidísimo y se llama Redmine. Aunque lleva creado desde 2006 no fue hasta 2018 que decidí implantarlo en mi empresa (y en la de algún cliente posteriormente). Aunque seguía sin ser perfecta nos ofrecía todo lo que necesitábamos para el control de tareas, nos permitía comunicarnos con los clientes via incidencias, llevar un tracking completo de todo en lo que hemos trabajado de cada proyecto, con múltiples proyectos completamente aislados unos de otros y con usuarios igualmente aislados y con roles diferenciados. Todos nuestros proyectos con mantenimiento se iniciaban como proyecto redmine y evolucionaba a proyecto de mantenimiento abierto a que los clientes pudieran dar de alta sus incidencias y hacer seguimiento de la evolución del mismo.

El mayor problema de redmine es que tremendamente poco intuitivo o, dicho en castellano «es feo de cojones». Aunque tiene todo lo que necesitamos para un equipo de desarrollo (aunque feo-feo), es imposible a día de hoy intentar que un cliente entre por el aro de reonocer esto como una aplicación web… Ahora se espera utilizar llamativos tableros kanvan (inutilizables cuando el número de tareas es alto o los equipos grandes) y modificaciones instantaneas via clicks y sin tener que escribir nada, solo pinchar y arrastrar. Me he pasado los últimos años buscando herramientas software libre que me permitiesen tener la misma privacidad y funcionalidad que redmine pero con un aspecto nuevo y renovado. He probado desde Trello hasta monday.com pasando por Jira y Asana (igual Jira no es tampoco demasiado atractivo). Quitando que ninguna de estas herramientas son libres de verdad y varias de ellas o son demasiado completas o carecen de alguna de las características que hemos descrito anteriormente todas ellas son carísimas… Sigo buscando ya que aunque redmine me viene bien para gestionar un equipo de desarrollo se atraganta a otro tipo de perfil menos hecho a lidiar con informes y formularios. ¿Conocéis alguno bueno y, a ser posible, open source o con una versión realmente barata?

Cómo Configurar Login con Office 365 (Microsoft Entra ID) en Authentik

Como ya vimos en la anterior entrada es bastante sencillo instalar un sistema SSO como authentik en nuestra infraestructura. De todas formas, crear un login centralizado no es más que una manera de tener que recordar menos contraseñas, pero el objetivo final es no tener que recordar más que unas pocas para poder acceder a todos los servicios, ¿qué hacemos si ya tenemos cuenta en alguno de los servicios más populares como office 365 o google? Lo suyo sería poder hacer login con estas credenciales en cualquier servicio, sea online o sea auto hospedado. Por suerte, authentik puede hacer uso de estos servicios externos de autenticación de manera «relativamente» sencilla. En este post os voy a explicar paso a paso (que sobre todo la parte a realizar con office es un poco liosa) cómo integrar el login de office 365 con authentik y así poder usarlo para acceder a nuestras aplicaciones (eso ya lo explicaremos en próximos posts).

Para poder realizar este tutorial debes tener:

  • Servidor authentik instalado y configurado (con acceso como administrador)
  • Cuenta de administrador office365 de tu organización
  • Un poco de paciencia (esto nunca viene mal)

Paso 1: registrar una aplicación de microsoft entra

Entramos como administrador en portal.office.com

Pedimos que nos muestre todas las opciones (estos de MS suelen ocultarnos cosas)

Seleccionamos la opción Identidad (nos llevará a entra)

Seleccionamos la opción Registro de aplicaciones

Y seleccionamos Nuevo registro

Y rellenamos los datos básicos (yo voy a llamar authentik a la nueva aplicación)

Hemos elegido que solo se pueda entrar con cuentas de nuestra organización, que será lo normal, aunque si queremos que cualquiera que tenga una cuenta de office365 pueda hacer logn tendremos que escoger una de las otras opciones. Atento a la ui de redirección, en principio tendrá el formato https://<direccion-de-tu-authentik>/source/oauth/callback/<nombre-de-fuente> Si no lo configuras ahora lo podrás hacer después cuando termines la configuración en authentik.

Anotamos los datos que vamos a necesitar de la aplicación y creamos un nuevo secreto:

Es muy importante que copiemos el valor del secreto que lo vamos a necesitar luego

El valor del secreto no se va a poder copiar en otro momento, mejor que lo guardes ahora.

Con esto hemos terminado (en principio) con la configuración necesaria en el portal de office. Lo que hemos hecho, básicamente, es configurar los endpoints de oauth2 que podemos consultar en la opción.

Paso 2: crear un nuevo login social

Las siguientes acciones las haremos como administrador en nuestro servidor authentik

El primer paso es crear un inicio de sesión federado

del tipo azure AD

Ahora deberemos introducir todos los datos que hemos guardado al crear la aplicación en entra:

Los endpoint serán como estos (revisar los que vimos en la pantalla del portal de office):

Cambiaremos la URL del perfil a https://graph.microsoft.com/oidc/userinfo

Y damos a terminar por ahora. Esto nos configura el método para entrar usando las credenciales de Microsoft, pero todavía nos falta un par de cosas para que sea útil del todo.

Paso 3: mapeo de atributos

Ahora necesitamos hacer la equivalencia entre los atributos que vienen de office con los que nosotros vamos a utilizar en nuestro directorio, para eso crearemos una política de expresión:

La llamamos (por ejemplo) azure-ad-mapping y ponemos este contenido:

# save existing prompt data
current_prompt_data = context.get('prompt_data', {})
# make sure we are used in an oauth flow
if 'oauth_userinfo' not in context:
  ak_logger.warning(f"Missing expected oauth_userinfo in context. Context{context}")
  return False
oauth_data = context['oauth_userinfo']
# map fields directly to user left hand are the field names provided by
# the microsoft graph api on the right the user field names as used by authentik
required_fields_map = {
  'name': 'username',
  'email': 'email',
  'given_name': 'name'
}
missing_fields = set(required_fields_map.keys()) - set(oauth_data.keys())
if missing_fields:
  ak_logger.warning(f"Missing expected fields. Missing fields {missing_fields}.")
  return False
for oauth_field, user_field in required_fields_map.items():
  current_prompt_data[user_field] = oauth_data[oauth_field]
# Define fields that should be mapped as extra user attributes
attributes_map = {
  'name': 'upn',
  'sub': 'sn',
  'name': 'name'
}
missing_attributes = set(attributes_map.keys()) - set(oauth_data.keys())
if missing_attributes:
  ak_logger.warning(f"Missing attributes: {missing_attributes}.")
  return False
# again make sure not to overwrite existing data
current_attributes = current_prompt_data.get('attributes', {})
for oauth_field, user_field in attributes_map.items():
  current_attributes[user_field] = oauth_data[oauth_field]
current_prompt_data['attributes'] = current_attributes
context['prompt_data'] = current_prompt_data
return True

Paso 4: configurar el flujo de alistamiento

Queremos que cualquiera que tenga cuenta en el dominio office pueda entrar a nuestras aplicaciones, por lo que necesitamos registrar los usuarios nuevos cuando entran por primera vez, para ello vamos a crear uun flujo nuevo.

Le ponemos un nombre

Y una vez creado, editarlo, ir a la sección d Vinculaciones de Políticas / Grupos / Usuarios y ahí a Bind existing policy

Y ahí ligar defaultsource-enrollment-if-sso

Ir ahora a vinculos de etapa -> Bind Existing stage

Añadir default-source-enrollment-write (orden 0) y default-source-enrollment-login (orden 10)

Desplegar luego la etapa con orden cero y añadir una política existente azur-ad-mapping que creamos antes:

Por último editarmos la fuente que creamos al principio (Directory -> Federation ..) y le añadimos en la configuración de flujo el flujo de inscrpción a azure-ad-enrollment (o el nombre que le hayamos puesto)

Paso 5: hacer que se vea en el login

Pues ya solo nos faltaría hacer que aparezca una opción para hacer login con este proveedor, esto se hace editando el flujo default-authentication-flow

Y editas la etapa

Y añades desde las fuentes disponibles a Fuentes seleccionadas

Ahora cuando entres en tu authentik ya te aparecerá la opción nueva para acceder. La primera vez que accedas debes aprobar unos permisos especiales a Microsoft:

Ha sido un proceso un poco largo, pero ahora ya tenéis centralizada la información de seguridad y cualquier aplicación que pueda conectarse a authentik podrá usar los usuarios de nuestro dominio… Ahora queda que lo probéis vosotros.

Instala tu propio servidor SSO (Single Sing-On)

Es posible que, como nosotros, ester harto de tantas contraseñas y tantas veces que tienes que autenticarte para acceder a tus aplicaciones. Nosotros ya inventamos nomorepass para no tener que andar recordando la contraseñas, pero eso no quita a que cada vez que instalamos un nuevo sistema en nuestro laboratorio personal nos toque volver a lidiar con las credenciales de acceso. Hay veces que intentamos centralizarlo en algún proveedor externo (como google o microsoft), pero esto no es del todo seguro y corremos el riesgo de tener que andar configurando nuestras aplicaciones con credenciales que, como las de Microsoft Hello caducan cada cierto tiempo.

Por eso os propongo algo mejor, ¿porqué no hospedar nosotros nuestro propio sistema de autenticación? En este post vamos a ver como instalar y configurar uno de los más populares y potentes sistemas SSO: Authentik. La instalación es bastante sencilla y está bien explicada en su documentación. Os resumo cómo quedaría la cosa. Necesitamos:

  • Servidor donde instalarlo (2VCPU / 2Gb memoria mínimo)
  • Docker y docker compose (v2 mejor)
  • wget y openssl instalado (necesarios solo para la instalación)

Una vez que tenemos el servidor con docker y docker compose instalado nos descargamos la plantilla:

wget https://goauthentik.io/docker-compose.yml

Y generamos los elementos de seguridad necesarios y los guardamos en el archivo .env

echo "PG_PASS=$(openssl rand -base64 36 | tr -d '\n')" >> .env
echo "AUTHENTIK_SECRET_KEY=$(openssl rand -base64 60 | tr -d '\n')" >> .env

Con esto ya podemos arrancar el servidor. Hay cosas que sería recomendable configurar, como la salida de email, bien con un servidor propio, o podéis utilizar cualquier servicio que os ofrezca smtp. También se puede cambiar el puerto por el que se accede, que generalmente está en el 9000/9443 para cambiarlos a los estándar 80/443. Como ejemplo os dejo mi docker-compose y mi .env (cambiando las cosas privadas, claro):

services:
  postgresql:
    image: docker.io/library/postgres:16-alpine
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -d $${POSTGRES_DB} -U $${POSTGRES_USER}"]
      start_period: 20s
      interval: 30s
      retries: 5
      timeout: 5s
    volumes:
      - database:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: ${PG_PASS:?database password required}
      POSTGRES_USER: ${PG_USER:-authentik}
      POSTGRES_DB: ${PG_DB:-authentik}
    env_file:
      - .env
  redis:
    image: docker.io/library/redis:alpine
    command: --save 60 1 --loglevel warning
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "redis-cli ping | grep PONG"]
      start_period: 20s
      interval: 30s
      retries: 5
      timeout: 3s
    volumes:
      - redis:/data
  server:
    image: ${AUTHENTIK_IMAGE:-ghcr.io/goauthentik/server}:${AUTHENTIK_TAG:-2025.2.4}
    restart: unless-stopped
    command: server
    environment:
      AUTHENTIK_REDIS__HOST: redis
      AUTHENTIK_POSTGRESQL__HOST: postgresql
      AUTHENTIK_POSTGRESQL__USER: ${PG_USER:-authentik}
      AUTHENTIK_POSTGRESQL__NAME: ${PG_DB:-authentik}
      AUTHENTIK_POSTGRESQL__PASSWORD: ${PG_PASS}
    volumes:
      - ./media:/media
      - ./custom-templates:/templates
    env_file:
      - .env
    ports:
      - "${COMPOSE_PORT_HTTP:-9000}:9000"
      - "${COMPOSE_PORT_HTTPS:-9443}:9443"
    depends_on:
      postgresql:
        condition: service_healthy
      redis:
        condition: service_healthy
  worker:
    image: ${AUTHENTIK_IMAGE:-ghcr.io/goauthentik/server}:${AUTHENTIK_TAG:-2025.2.3}
    restart: unless-stopped
    command: worker
    environment:
      AUTHENTIK_REDIS__HOST: redis
      AUTHENTIK_POSTGRESQL__HOST: postgresql
      AUTHENTIK_POSTGRESQL__USER: ${PG_USER:-authentik}
      AUTHENTIK_POSTGRESQL__NAME: ${PG_DB:-authentik}
      AUTHENTIK_POSTGRESQL__PASSWORD: ${PG_PASS}
    user: root
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./media:/media
      - ./certs:/certs
      - ./custom-templates:/templates
    env_file:
      - .env
    depends_on:
      postgresql:
        condition: service_healthy
      redis:
        condition: service_healthy

volumes:
  database:
    driver: local
  redis:
    driver: local

.env:

PG_PASS=<esto-lo-tienes-que-generar>
AUTHENTIK_SECRET_KEY=<esto-lo-generas-tambien>
AUTHENTIK_ERROR_REPORTING__ENABLED=true
# SMTP Host Emails are sent to
AUTHENTIK_EMAIL__HOST=mail.biblioeteca.net
AUTHENTIK_EMAIL__PORT=587
[email protected]
AUTHENTIK_EMAIL__PASSWORD=<el que sea>
AUTHENTIK_EMAIL__USE_TLS=false
AUTHENTIK_EMAIL__USE_SSL=false
AUTHENTIK_EMAIL__TIMEOUT=10
[email protected]
AUTHENTIK_TAG=2025.6.2

Si todo hay ido bien ya puedes arrancarlo:

docker compose up -d

Y ya puedes empezar a configurar tu nuevo SSO navegando a la página:

http://<IP servidor>:9000/if/flow/initial-setup/

Con esto ya tenemos un sistema que nos permite hacer login con los usuarios que queramos… ¿Qué más podemos hacer con este sistema?… Pues un montón de cosas. Quedaos atentos y en los siguientes posts os enseñaré como hacer cosas interesantes como conectar con sistemas externos (como office365 o google) y hacer uso de esas credenciales.

El mejor gestor de fotos autohospedado

Durante mucho tiempo he ido guardando las fotos que hacía, primero con varias cámaras digitales, posteriormente con distintos móviles en un directorio (o varios) de mi ordenador (posteriormente de alguno de los NAS que he montado). Preservar las fotos es algo que es muy importante para mi, son recuerdos enlatados que te permiten revivir los buenos (o no tan buenos) momentos del pasado y que sería traumático perder del todo.

El caso es que para poder clasificarlas, al menos por fecha, he estado usando varias opciones, google nos permitía guardar las fotos en una resolución menguante, aunque decía que así eran ilimitadas, hubo un momento en que Amazon ofreció lo mismo, pero se perdió en la bruma del tiempo, flickr y 500px se volvieron de pago y solo eran para fotos públicas. Finalmente termine utilizando el programa shotwell para ubuntu que me permitía importar las fotos nuevas y guardarlas en local… Synology también tenía su propio programa de fotografías pero era… muy malo.

Hasta que finalmente descubrí immich. Este sistema, open source completo, te permite guardar, organizar y gestionar tus fotos y videos fácilmente sin sacrificar privacidad. Te comento aquí los pasos más sencillos para tenerlo funcionando:

Básicamente tienes que tener un host o máquina virtual que tenga, al menos, 4Gb de memoria, un montón de disco duro para guardar todas las imágenes, docker y docker compose instalados.

Luego hay ciertas cosas que podrías querer hacer con IA y para las que podría venir bien tener una tarjeta gráfica… Pero eso es otra historia que no vamos a contar aquí.

Este sería el docker-compose.yml


name: immich

services:
  immich-server:
    container_name: immich_server
    image: ghcr.io/immich-app/immich-server:${IMMICH_VERSION:-release}
    volumes:
      - ${UPLOAD_LOCATION}:/usr/src/app/upload
      - /etc/localtime:/etc/localtime:ro
    env_file:
      - .env
    ports:
      - '2283:2283'
    depends_on:
      - redis
      - database
    restart: always
    healthcheck:
      disable: false

  immich-machine-learning:
    container_name: immich_machine_learning
    image: ghcr.io/immich-app/immich-machine-learning:${IMMICH_VERSION:-release}
    volumes:
      - model-cache:/cache
    env_file:
      - .env
    restart: always
    healthcheck:
      disable: false

  redis:
    container_name: immich_redis
    image: docker.io/valkey/valkey:8-bookworm@sha256:fec42f399876eb6faf9e008570597741c87ff7662a54185593e74b09ce83d177
    healthcheck:
      test: redis-cli ping || exit 1
    restart: always

  database:
    container_name: immich_postgres
    image: ghcr.io/immich-app/postgres:14-vectorchord0.4.3-pgvectors0.2.0
    environment:
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_USER: ${DB_USERNAME}
      POSTGRES_DB: ${DB_DATABASE_NAME}
      POSTGRES_INITDB_ARGS: '--data-checksums'
    volumes:
      - ${DB_DATA_LOCATION}:/var/lib/postgresql/data
    restart: always

volumes:
  model-cache:

Luego hay que crear un .env con los valores personalizados para nuestra instalación:


UPLOAD_LOCATION=./library
DB_DATA_LOCATION=./postgres
TZ=Europe/Madrid
IMMICH_VERSION=release
DB_PASSWORD=pon-aqui-un-password-para-postgres
DB_USERNAME=postgres
DB_DATABASE_NAME=immich

Obviamente elige el directorio que quieras para la bbdd y de donde vas a guardar las fotos y… Ya estaría.

docker compose up -d

Y ya tendrías una instalación vacía de immich lista para empezar a jugar. Lo primero que tendrás que hacer es crear la primera cuenta del sistema, que será de administración conectando con http://<dir-ip>:2283. A partir de ese momento ya podrás empezar a subir fotos como si no hubiese un mañana… De hecho puedes subir directorios enteros. Eso si, el tratamiento de las fotos tarda un poco porque se dedica a recopilar los datos internos de las fotos y a reconocer caras (para que luego puedas navegar por ellas), pero una vez que ya ha cogido ritmo cada foto subida va más rápido.

¿Qué más?

Es muy recomendable usar la aplicación móvil para sincronizar las fotos del teléfono con immich automáticamente, os dejo las direcciones para Android y iphone:

Cuando arranquéis la app os pedirá que pongáis la dirección de vuestro servidor (si tenéis una ip local solo funcionará dentro de vuestra red) y luego os pedirá que os autentiqueis momento a partir del cual ya podréis hacer copia de seguridad de los albumes que queráis de vuestro móvil (yo solo subo los de la cámara, whatsapp y demás no son demasiado «preservables»).

Y con esto ya estaría todo (salvo que queráis poner un proxy inverso para acceder desde fuera de vuestra red o un tunel de cloudflare o similar)… Eso si, reservad disco suficiente porque vais a necesitarlo…

Instala tu propia perplexity ia (perplexica)

Uno de los sistemas de IA más completos para las actividades diarias es perplexity.ia un sistema que no solo responde preguntas (usando varios proveedores de IA) sino que realiza una búsqueda en internet previa de los conceptos principales por los que estamos preguntando.

El problema principal es que, además de que es un sistema de pago, que todos los datos se los estamos pasando a una empresa que, a pesar de los términos y condiciones que nadie se lee, es posible que esté usando nuestros datos para sus propios fines. Sin embargo, he descubierto que hay un sistema open source que te permite montar un sistema similar a perplexity… El nombre ya da alguna pista: preplexica.

El repositorio principal lo podéis encontar aquí: https://github.com/ItzCrazyKns/Perplexica

En este post vamos a ver cómo utilizar el montaje que hicimos en un post anterior: Como tener tu propia IA en casa donde terminamos teniendo un servidor ollama para tener instalados los modelos open source que queramos y un servidor webui para poder interrogar a los modelos. Lo primero que vamos a hacer es modificar el docker-compose.yml para compartir el puerto por el que hablar con ollama de esta manera:

    ports:
      - "11434:11434"

Esto hace que ya esté disponible desde fuera del contenedor los modelos de ollama. Lo siguiente que tenemos que hacer es bajarnos el repositorio de Perpléxica

git clone https://github.com/ItzCrazyKns/Perplexica
cd Perplexica
cp sample.config.toml config.toml

Dado que el puerto 3000 que es en el que se ejecuta el servidor ya está ocupado por nuestro servicio webui vamos a cambiarlo al 3001 en el archivo docker-compose.yml que hay dentro del directorio Perplexica y lo dejaremos así (el otro puerto que utiliza es el 4000, si ese lo tenemos ocupado podemos cambiarlo en el otro servicio):

    ports:
      - 3001:3000

Luego modificaremos el archivo config.toml que copiamos anteriormente y modificaremos esta parte:

[MODELS.OLLAMA]
API_URL = "http://192.168.1.34:11434"

Poniendo la IP de la máquina en la que se está ejecutando. Ya solo tenemos que levantar el docker… docker compose up -d y conectar con http://localhost:3001 y ya tendremos nuestro intefaz de búsqueda

En la configuración (icono de abajo a la izquierda) podemos configurar los modelos que queremos utilizar:

Y si tenemos Claves de APIs de pago podemos incluirlas igualmente:

Y, con esto ya podremos empezar a preguntar a nuestro nuevo sistema de búsqueda (lo que tarde dependerá más del modelo elegido que de las búsquedas). Lo bueno es que puedes decirle que busque imágenes y videos a la vez:

Así que, ya sabéis, si tenéis una tarjeta gráfica lo suficientemente potente para correr un modelo de AI interesante, podéis mezclarlo con las búsquedas por internet de varias fuentes de una manera muy sencilla..