Ollama es principalmente un contenedor de llama.cpp, diseñado para tareas de inferencia local. Por lo general, no es su primera opción si busca rendimiento o características de vanguardia, pero tiene sus usos, especialmente en entornos donde las dependencias externas son una preocupación.

Desarrollo local de IA

Cuando se utiliza Ollama para el desarrollo local de IA, la configuración es sencilla pero efectiva. Los desarrolladores suelen aprovechar Ollama para ejecutar tareas de inferencia directamente en sus máquinas locales. Aquí hay una representación visual de una configuración típica de desarrollo local usando Ollama:

Esta configuración permite a los desarrolladores probar e iterar rápidamente sin las complejidades de las comunicaciones del servidor remoto. Es ideal para las fases iniciales de creación de prototipos y desarrollo, donde la respuesta rápida es fundamental.

De lo local a la nube

La transición de una configuración local a un entorno de nube escalable implica evolucionar desde una configuración simple 1:1 (una solicitud de usuario a un host de inferencia) a una configuración más compleja de muchos a muchos (múltiples solicitudes de usuario a múltiples hosts de inferencia) . Este cambio es necesario para mantener la eficiencia y la capacidad de respuesta a medida que aumenta la demanda.

Así es como se ve este escalamiento cuando se pasa del desarrollo local a la producción:

Adoptar un enfoque sencillo durante esta transición puede aumentar significativamente la complejidad de las aplicaciones, especialmente porque las sesiones deben mantener la coherencia en varios estados. Pueden surgir retrasos e ineficiencias si las solicitudes no se enrutan de manera óptima al mejor host de inferencia disponible.

Además, la naturaleza compleja de las aplicaciones distribuidas hace que sea difícil probarlas localmente, lo que puede ralentizar el proceso de desarrollo y aumentar el riesgo de fallos en los entornos de producción.

Sin servidor

La informática sin servidor abstrae los detalles de la infraestructura y la administración del servidor, lo que permite a los desarrolladores centrarse únicamente en el código y la lógica empresarial. Al desacoplar el manejo de solicitudes y el mantenimiento de la coherencia de la aplicación, la arquitectura sin servidor simplifica el escalamiento.

Este enfoque permite que la aplicación permanezca concentrada en ofrecer valor, resolviendo muchos desafíos de escalamiento comunes sin sobrecargar a los desarrolladores con complejidades de infraestructura.

Asamblea web

WebAssembly (Wasm) aborda el desafío de la gestión de dependencias al permitir la compilación de aplicaciones en módulos autónomos. Esto hace que las aplicaciones sean más fáciles de organizar y probar tanto localmente como en la nube, lo que garantiza la coherencia en diferentes entornos.

tau

Tau es un marco para construir plataformas de computación en la nube altamente escalables y de bajo mantenimiento. Destaca por su simplicidad y extensibilidad. Tau simplifica la implementación y admite la ejecución de una nube local para el desarrollo, lo que permite realizar pruebas de extremo a extremo (E2E) tanto de la infraestructura de la nube como de las aplicaciones que se ejecutan en ella.

Este enfoque, al que Taubyte se refiere como "Codificación local equivale a producción global", garantiza que lo que funciona localmente funcionará globalmente, lo que facilita significativamente los procesos de desarrollo e implementación.

Integrando Ollama en Tau con el sistema de complemento Orbit

El sistema de complementos de Tau, conocido como Orbit, simplifica significativamente convertir servicios en componentes manejables envolviéndolos en módulos host de WebAssembly. Este enfoque permite a Tau asumir las tareas de orquestación, agilizando el proceso de implementación y gestión.

Exportación de Funciones en Ollama

Para que las funciones de Ollama sean accesibles dentro del ecosistema de Tau, utilizamos el sistema Orbit para exportar las capacidades de Ollama como puntos finales invocables. Así es como puedes exportar un punto final en Go:

func (s *ollama) W_pull(ctx context.Context, module satellite.Module, modelNamePtr uint32, modelNameSize uint32, pullIdptr uint32) Error {
    model, err := module.ReadString(modelNamePtr, modelNameSize)
    if err != nil {
        return ErrorReadMemory
    }

    id, updateFunc := s.getPullId(model)

    if updateFunc != nil {
        go func() {
            err = server.PullModel(s.ctx, model, &server.RegistryOptions{}, updateFunc)
            s.pullLock.Lock()
            defer s.pullLock.Unlock()
            s.pulls[id].err = err
        }()
    }

    module.WriteUint64(pullIdptr, id)

    return ErrorNone
}

Para ver un ejemplo sencillo de funciones de exportación, puedes consultar el ejemplo de hello_world.

Una vez definidas, estas funciones, ahora llamadas vía satélite.Exportar, permiten la perfecta integración de Ollama en el entorno de Tau:

func main() {
    server := new(context.TODO(), "/tmp/ollama-wasm")
    server.init()
    satellite.Export("ollama", server)
}

Pruebas de escritura para el complemento Ollama

Probar el complemento es sencillo y ágil. Así es como puedes escribir una prueba de función sin servidor en Go:

//export pull
func pull() {
    var id uint64
    err := Pull("gemma:2b-instruct", &id)
    if err != 0 {
        panic("failed to call pull")
    }
}

Utilizando el conjunto de pruebas de Tau y las herramientas de creación de Go, puedes crear tu complemento, implementarlo en un entorno de prueba y ejecutar las funciones sin servidor para verificar la funcionalidad:

func TestPull(t *testing.T) {
    ctx := context.Background()

    // Create a testing suite to test the plugin
    ts, err := suite.New(ctx)
    assert.NilError(t, err)

    // Use a Go builder to build plugins and wasm
    gob := builder.New()

    // Build the plugin from the directory
    wd, _ := os.Getwd()
    pluginPath, err := gob.Plugin(path.Join(wd, "."), "ollama")
    assert.NilError(t, err)

    // Attach plugin to the testing suite
    err = ts.AttachPluginFromPath(pluginPath)
    assert.NilError(t, err)

    // Build a wasm file from serverless function
    wasmPath, err := gob.Wasm(ctx, path.Join(wd, "fixtures", "pull.go"), path.Join(wd, "fixtures", "common.go"))
    assert.NilError(t, err)

    // Load the wasm module and call the function
    module, err := ts.WasmModule(wasmPath)
    assert.NilError(t, err)

    // Call the "pull" function from our wasm module
    _, err = module.Call(ctx, "pull")
    assert.NilError(t, err)
}

Código

Puedes encontrar el código completo aquí https://github.com/ollama-cloud/ollama-as-wasm-plugin/tree/main/tau

¿Que sigue?

Ahora puede crear aplicaciones LLM con facilidad. Estos son los pasos para comenzar:

• Comience a usar dream localmente: configure su entorno local para desarrollar y probar su aplicación.
• Crea un proyecto: comienza un nuevo proyecto con Tau para aprovechar todo su potencial.
• Crea tu nube de producción: implementa tu proyecto en un entorno de nube de producción.
• Suelte el binario del complemento en la carpeta /tb/plugins.
• Importa tu proyecto a producción
• ¡Presumir!