Funcionaba, pero había un pequeño problema: cada vez que me surgía una duda programando, tenía que salir de Xcode, abrir LM Studio, explicar el contexto y copiar y pegar código. No era el fin del mundo, pero cuando intentas entender por qué una función usa async, por qué aparece un error o cómo funciona una propiedad de SwiftUI, cambiar de ventana continuamente rompe el ritmo.

Así que me planteé una pregunta:

¿Y si pudiera hablar con mi maestro de Swift directamente desde Xcode?

Pensé que necesitaría desarrollar una integración o montar un servidor intermedio. Pero resulta que Xcode ya permite conectarse a modelos alojados localmente. Y ahí comenzó esta segunda parte.

Qué vamos a conseguir

El objetivo es que Xcode pueda comunicarse directamente con el modelo de IA que tenemos ejecutándose en LM Studio.

La conexión es bastante sencilla:

Xcode
  │
  ▼
Coding Intelligence
  │
  ▼
LM Studio (localhost:1234)
  │
  ▼
Modelo Swift 7B
  │
  ▼
Respuesta dentro de Xcode

Lo interesante es que no necesitamos subir nuestro proyecto a ningún servicio externo para utilizar este asistente.

Si configuramos LM Studio para escuchar únicamente en localhost y utilizamos el proveedor local, las peticiones de este modelo se procesan dentro de nuestro Mac.

Esto me parece especialmente atractivo: poder utilizar inteligencia artificial para aprender programación sin depender constantemente de servicios en la nube.

Eso sí, hay una diferencia importante: estamos conectando un modelo de chat, no instalando un agente capaz de controlar todo Xcode por su cuenta.

Qué necesitamos

Antes de empezar, estos son los ingredientes:

En mi caso, lo que más me interesa es poder hacer consultas sobre Swift, SwiftUI y Swift Concurrency sin tener que abandonar el editor.

Paso 1: poner en marcha el servidor de LM Studio

Lo primero es conseguir que LM Studio pueda recibir peticiones desde otra aplicación.

Para ello:

  1. Abrimos LM Studio.
  2. Cargamos nuestro modelo.
  3. Entramos en la pestaña Developer.
  4. Activamos Start Server.
  5. Comprobamos que el servidor está funcionando en el puerto 1234.
  6. Al cargar el modelo, revisamos la longitud de contexto. Xcode puede enviar bastante código en cada consulta, y si es demasiado corta las respuestas se cortan o pierden información. Pero cuanto más grande, más memoria consume.

La dirección habitual es:

http://localhost:1234

LM Studio incorpora una API compatible con OpenAI. Esto significa que otras aplicaciones pueden comunicarse con nuestro modelo mediante peticiones HTTP, utilizando endpoints conocidos.

Los dos que más nos interesan son:

GET  /v1/models
POST /v1/chat/completions

El primero permite consultar los modelos disponibles y el segundo enviar conversaciones y recibir respuestas.

Y no, esto no implica que estemos utilizando los servidores de OpenAI. Únicamente estamos utilizando un formato de API compatible.

Por seguridad, mantendremos el servidor limitado a nuestro propio equipo, sin activar la opción de compartirlo por la red local.

Paso 2: comprobar que nuestro modelo responde

Antes de abrir Xcode, me gusta comprobar que cada pieza funciona por separado.

Es una costumbre bastante útil cuando estás aprendiendo programación: si algo falla, es mejor saber dónde está el problema antes de empezar a cambiar configuraciones a ciegas.

Abrimos Terminal y ejecutamos:

curl http://localhost:1234/v1/models

Si todo está correctamente configurado, recibiremos una respuesta JSON con información sobre los modelos disponibles.

Por ejemplo, encontraremos un identificador parecido a este:

{
  "data": [
    {
      "id": "identificador-de-tu-modelo",
      "object": "model"
    }
  ]
}

El nombre concreto dependerá del modelo que tengamos cargado.

Si recibimos la respuesta, ya sabemos que el servidor está escuchando y que podemos comunicarnos con él.

Si aparece un error de conexión, revisaremos que LM Studio siga abierto, que el servidor esté iniciado y que estemos utilizando el puerto correcto.

Paso 3: conectar LM Studio con Xcode

Ahora viene la parte más interesante.

Abrimos Xcode y seguimos estos pasos:

  1. Accedemos a Xcode → Settings.
  2. Entramos en Intelligence.
  3. En la sección de chat, pulsamos Add a Chat Provider.
  4. Seleccionamos Locally Hosted.
  5. Introducimos el puerto 1234.
  6. Añadimos una descripción, por ejemplo Mi maestro Swift - LM Studio.
  7. Pulsamos Add para guardar la configuración.

Xcode utiliza la API de Chat Completions para comunicarse con el servidor local.

En otras palabras, Xcode no necesita conocer cómo funciona internamente nuestro modelo. Solo necesita saber dónde está escuchando y cómo enviarle las preguntas.

Esto es una de las cosas que más me gustan del desarrollo de software: cuando diferentes herramientas utilizan estándares compatibles, integrar sistemas puede resultar mucho más sencillo de lo que imaginabas.

Paso 4: hablar con nuestro maestro desde Xcode

Con el servidor iniciado y el proveedor añadido, abrimos uno de nuestros proyectos Swift.

Podemos acceder al asistente de código pulsando:

⌘ + 0

En la barra de conversaciones, pulsamos New Conversation y seleccionamos nuestro modelo local en la sección Chat. También podemos abrir el asistente con el botón Coding Assistant.

Y ahora sí, podemos empezar a preguntarle cosas mientras trabajamos.

Por ejemplo, imaginemos que estamos estudiando Swift Concurrency y encontramos esta función:

func obtenerUsuarios() async throws -> [Usuario] {
    try await servicio.fetchUsers()
}

Podríamos preguntarle:

Estoy aprendiendo Swift Concurrency. Explícame qué hacen async, throws y await en esta función. Quiero entenderlo paso a paso, con ejemplos sencillos y sin modificar el código.

Esta forma de utilizar la inteligencia artificial me parece mucho más interesante que pedirle directamente que nos escriba toda una función.

Porque hay una diferencia enorme entre conseguir que el código funcione y entender realmente por qué funciona.

Y si quiero dedicarme profesionalmente al desarrollo iOS, lo segundo me parece imprescindible.

También podemos aprovechar el contexto relevante que proporciona Xcode al asistente. Según cómo organicemos la conversación, podemos hacer referencia a archivos y símbolos concretos del proyecto.

No significa que el modelo vaya a conocer automáticamente cada rincón de nuestra aplicación, pero sí que podemos evitar parte del trabajo de copiar y pegar código.

¿Y qué ocurre con la privacidad?

Uno de los motivos por los que empecé a investigar modelos locales era poder tener más control sobre mis datos.

En esta configuración, Xcode envía las consultas al servidor de LM Studio que está funcionando en nuestro Mac.

El modelo procesa la información localmente y devuelve la respuesta al editor.

Si estamos utilizando exclusivamente este proveedor y el servidor no está expuesto a la red, no necesitamos enviar esas peticiones a un proveedor de IA externo.

Eso no significa que todas las funciones de Xcode o de macOS funcionen sin conexión. La privacidad que estamos describiendo corresponde a este flujo concreto entre Xcode y LM Studio.

Y, por supuesto, seguimos siendo responsables de revisar el código que compartimos con cualquier herramienta.

No todo es perfecto: algunas cosas que debemos tener en cuenta

Hay varios puntos que conviene conocer antes de empezar a utilizar el sistema a diario.

El rendimiento depende del Mac, y la memoria se nota. En mi caso, cargar el modelo supuso unos 14 GB adicionales de memoria, bastante más de lo que sugiere el tamaño de un 7B. Con otras aplicaciones abiertas, el sistema empezó a usar swap y se notó en la fluidez.

La cuantización exacta de mi modelo está pendiente de confirmar. Antes de cargarlo, merece la pena revisar la cuantización (cuanto más ligera, menos memoria) y la longitud de contexto, y comprobar en Monitor de Actividad que no hay más de un modelo cargado.

La ventana de contexto también importa. Si Xcode envía muchos fragmentos de código, el modelo puede quedarse sin espacio para procesarlos. Ya vimos en el Paso 1 dónde ajustarla; habrá que adaptarla al modelo y a los recursos disponibles.

El modelo se puede equivocar. Especialmente cuando trabajamos con versiones recientes de Swift o con APIs que han cambiado. Que una respuesta suene convincente no significa que sea correcta.

Por eso, mi planteamiento sigue siendo el mismo: consultar, contrastar con la documentación oficial, probar en Xcode y comprender lo que estoy haciendo.

La limitación que no debemos pasar por alto: ¿dónde está mi documentación?

Aquí aparece una diferencia importante respecto a la primera parte del artículo.

Cuando configuré LM Studio, añadí documentación de Swift, material del Swift Developer Program 2024 y ejemplos de código para poder hacer preguntas sobre ellos.

Sin embargo, los documentos incorporados al chat de LM Studio no se transfieren automáticamente a las peticiones que llegan desde Xcode.

El sistema de consulta de documentos, o RAG, funciona dentro de la conversación de LM Studio en la que está configurado.

Cuando utilizamos Xcode a través de la API, nuestro modelo recibe las instrucciones y el contexto que Xcode le proporciona, pero no hereda automáticamente toda esa biblioteca de documentos.

Esto significa que, si quiero hacer una pregunta relacionada específicamente con las explicaciones de mis clases, seguiré necesitando utilizar el entorno de LM Studio donde tengo incorporado ese material.

Y aquí es donde aparece una idea para el futuro.

El siguiente paso: conectar también mi documentación

¿Y si consiguiéramos que Xcode no solo hablara con nuestro modelo, sino que también pudiera consultar toda nuestra documentación de Swift?

La arquitectura podría ser algo así:

Xcode
  │
  ▼
Proxy local
  │
  ├── Consulta mi documentación
  │       │
  │       ▼
  │   Recupera fragmentos útiles
  │
  ▼
Añade contexto a la consulta
  │
  ▼
LM Studio
  │
  ▼
Modelo Swift 7B
  │
  ▼
Respuesta en Xcode

La idea consistiría en crear un pequeño servicio intermedio que recibiera las preguntas de Xcode, buscara información relevante en mis documentos y añadiera esos fragmentos antes de enviar la consulta al modelo.

No tendría por qué ser una infraestructura complicada, aunque habría que resolver correctamente la búsqueda de información, la compatibilidad con la API y los límites de contexto.

De momento, es una idea para una posible tercera parte.

Antes prefiero comprobar hasta qué punto la conexión directa entre Xcode y LM Studio cubre mis necesidades reales.

Al fin y al cabo, también estoy aprendiendo que no siempre es necesario construir la solución más compleja. A veces lo inteligente es empezar por lo sencillo y mejorar únicamente aquello que nos hace falta.

Mi objetivo no es que la IA programe por mí

Cuando empecé a estudiar Swift, una de las cosas que más echaba de menos era poder preguntar por qué algo funcionaba de determinada manera sin perder el hilo de lo que estaba haciendo.

Con un asistente local integrado en Xcode, esa ayuda está mucho más cerca del lugar donde realmente estoy aprendiendo: el editor de código.

No sustituye a mi profesor, ni a la documentación oficial de Apple, ni mucho menos a las horas que necesito dedicar a practicar, equivocarme y volver a intentarlo.

Pero sí puede convertirse en otra herramienta para seguir avanzando.

Porque mi objetivo no es que la inteligencia artificial escriba Swift por mí. Mi objetivo es aprender a escribirlo cada día un poco mejor.

Y si, además, puedo hacerlo con un modelo ejecutándose en mi propio Mac, mejor todavía.

Si la idea del proxy funciona, nos vemos en la tercera parte.


Recursos y documentación