Ollama est principalement un wrapper autour de llama.cpp, conçu pour les tâches d'inférence locales. Ce n'est généralement pas votre premier choix si vous recherchez des performances ou des fonctionnalités de pointe, mais il a son utilité, en particulier dans les environnements où les dépendances externes sont un problème.

Développement local de l'IA

Lors de l'utilisation d'Ollama pour le développement d'IA locale, la configuration est simple mais efficace. Les développeurs utilisent généralement Ollama pour exécuter des tâches d'inférence directement sur leurs machines locales. Voici une représentation visuelle d'une configuration de développement local typique utilisant Ollama :

Cette configuration permet aux développeurs de tester et d'itérer rapidement sans les complexités des communications avec le serveur distant. Il est idéal pour les phases initiales de prototypage et de développement où un délai d'exécution rapide est essentiel.

Du local au cloud

La transition d'une configuration locale vers un environnement cloud évolutif implique de passer d'une simple configuration 1:1 (une demande d'utilisateur à un hôte d'inférence) à une configuration plusieurs-à-plusieurs plus complexe (plusieurs demandes d'utilisateur à plusieurs hôtes d'inférence). . Ce changement est nécessaire pour maintenir l’efficacité et la réactivité à mesure que la demande augmente.

Voici à quoi ressemble cette mise à l'échelle lorsque l'on passe du développement local à la production :

L'adoption d'une approche simple pendant cette transition peut augmenter considérablement la complexité des applications, d'autant plus que les sessions doivent maintenir la cohérence entre les différents états. Des retards et des inefficacités peuvent survenir si les demandes ne sont pas acheminées de manière optimale vers le meilleur hôte d'inférence disponible.

De plus, la nature complexe des applications distribuées rend difficile leur test local, ce qui peut ralentir le processus de développement et augmenter le risque de pannes dans les environnements de production.

Sans serveur

L'informatique sans serveur résume les détails de la gestion des serveurs et de l'infrastructure, permettant aux développeurs de se concentrer uniquement sur le code et la logique métier. En dissociant la gestion des requêtes et la maintenance de la cohérence de l'application, l'architecture sans serveur simplifie la mise à l'échelle.

Cette approche permet à l'application de rester concentrée sur la création de valeur, en résolvant de nombreux problèmes de mise à l'échelle courants sans surcharger les développeurs avec des complexités d'infrastructure.

Assemblage Web

WebAssembly (Wasm) relève le défi de la gestion des dépendances en permettant la compilation d'applications dans des modules autonomes. Cela facilite l'orchestration et le test des applications, à la fois localement et dans le cloud, garantissant ainsi la cohérence dans les différents environnements.

Tau

Tau est un framework permettant de créer des plates-formes de cloud computing nécessitant peu de maintenance et hautement évolutives. Il excelle en simplicité et en extensibilité. Tau simplifie le déploiement et prend en charge l'exécution d'un cloud local pour le développement, permettant ainsi des tests de bout en bout (E2E) de l'infrastructure cloud et des applications qui y sont exécutées.

Cette approche, appelée par Taubyte « Le codage local équivaut à une production mondiale », garantit que ce qui fonctionne localement fonctionnera à l'échelle mondiale, facilitant considérablement les processus de développement et de déploiement.

Intégration d'Ollama dans Tau avec le système de plugin Orbit

Le système de plugins de Tau, connu sous le nom d'Orbit, simplifie considérablement la transformation des services en composants gérables en les encapsulant dans des modules hôtes WebAssembly. Cette approche permet à Tau de prendre en charge les tâches d'orchestration, rationalisant ainsi le processus de déploiement et de gestion.

Exporter des fonctions dans Ollama

Pour rendre les fonctions d'Ollama accessibles au sein de l'écosystème de Tau, nous utilisons le système Orbit pour exporter les capacités d'Ollama en tant que points de terminaison appelables. Voici comment exporter un point de terminaison dans 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
}

Pour un exemple simple d'exportation de fonctions, vous pouvez vous référer à l'exemple hello_world.

Une fois définies, ces fonctions, désormais appelées via satellite.Export, permettent l'intégration transparente d'Ollama dans l'environnement de Tau :

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

Rédaction de tests pour le plugin Ollama

Le test du plugin est simplifié et simple. Voici comment écrire un test de fonction sans serveur dans Go :

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

À l'aide de la suite de tests de Tau et des outils de création Go, vous pouvez créer votre plugin, le déployer dans un environnement de test et exécuter les fonctions sans serveur pour vérifier la fonctionnalité :

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)
}

Code

Vous pouvez trouver le code complet ici https://github.com/ollama-cloud/ollama-as-wasm-plugin/tree/main/tau

Et après?

Vous pouvez désormais créer facilement des applications LLM. Voici les étapes pour commencer :

• Commencez localement en utilisant dream : configurez votre environnement local pour développer et tester votre application.
• Créez un projet : démarrez un nouveau projet avec Tau pour exploiter tout son potentiel.
• Créez votre cloud de production : déployez votre projet dans un environnement cloud de production.
• Déposez le binaire du plugin dans le dossier /tb/plugins.
• Importez votre projet en production
• Frimer!