Lima cara untuk menggunakan Generative AI dalam JavaScript

Pembelajaran Mesin dan pembangunan AI secara tradisinya dikuasai oleh Python dan kerana itu ekosistem tutorial, perpustakaan dan contoh didominasi terutamanya oleh Python. Walau bagaimanapun, dengan peningkatan konsep Jurutera AI, kami melihat lebih banyak pembangun web tindanan penuh mula mengusahakan AI, dan dengan itu permintaan untuk perkakasan serasi JavaScript/Typescript meningkat. Malah pada Februari 2024, Jared Palmer dari Vercel juga mendakwa bahawa "Jurutera AI masa depan ialah jurutera TypeScript".

Dalam catatan blog ini, kami akan melalui lima cara bagaimana anda sebagai pembangun JavaScript boleh menggunakan alatan AI generatif yang berbeza tanpa mempelajari kemahiran Python anda.

Cloud API

Jika anda baru bermula dan terutamanya jika anda merancang untuk menggunakan Model Bahasa Besar (LLM) seperti model GPT OpenAI atau model Claude Anthropic menggunakan API mereka secara langsung boleh menjadi permulaan yang sangat baik.

Berinteraksi dengan model hanya memerlukan satu panggilan sahaja.

fetch("https://api.openai.com/v1/chat/completions", {
 body: JSON.stringify({
    "model": "gpt-4o-mini",
    "messages": [
      {
        "role": "system",
        "content": "You are a helpful assistant."
      },
      {
        "role": "user",
        "content": "Who won the world series in 2020?"
      },
      {
        "role": "assistant",
        "content": "The Los Angeles Dodgers won the World Series in 2020."
      },
      {
        "role": "user",
        "content": "Where was it played?"
      }
 ]
  }),
 headers: {
 Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
    "Content-Type": "application/json"
  },
 method: "POST"
})

Malah, API "Penyelesaian Sembang" OpenAI telah menjadi standard de-facto untuk banyak penyedia model lain. Penyedia seperti Groq atau Together.ai menyediakan keserasian OpenAI bermakna anda hanya perlu menukar URL untuk bertukar kepada penyedia lain untuk memilih model yang berbeza.

Jika anda ingin menggunakan model lain, terdapat juga penyedia seperti Replicate yang pakar dalam mengehos model sumber terbuka dengan REST API yang konsisten malah mendedahkan API untuk memperhalusi beberapa model pada platform mereka.

Docker

Walaupun Cloud API bagus untuk bermula, kadangkala anda tidak mahu bergantung pada pembekal yang dihoskan awan untuk kes penggunaan anda. Sebagai contoh, mungkin anda ingin menjalankan model seperti Llama 3 8B secara eksplisit secara langsung pada mesin tempatan anda atau anda ingin menggunakan perpustakaan sumber terbuka seperti Unstructured.io yang ditulis dalam Python dan menggunakannya dalam projek JavaScript anda tanpa membayar untuk yang dihoskan API.

Sesetengah projek menyediakan atas sebab itu bekas Docker yang akan mendedahkan API HTTP apabila dijalankan. Sebagai contoh, anda boleh memulakan bekas Docker API Tidak Berstruktur dengan menjalankan:

docker run -p 8000:8000 -d --rm --name unstructured-api downloads.unstructured.io/unstructured-io/unstructured-api:latest 
--port 8000 --host 0.0.0.0

Setelah bekas berjalan, anda kini mempunyai versi localhost API Tidak Berstruktur yang boleh anda gunakan untuk memecah dokumen untuk disimpan kemudian dalam pangkalan data vektor anda.

const form = new FormData();

const buffer = // e.g. `fs.readFileSync('./fileLocation');
const fileName = 'test.txt';

form.append('file', buffer, {
 contentType: 'text/plain',
 name: 'file',
 filename: fileName,
});

const response = await fetch('http://localhost:8000/general/v0/general', { 
 method: 'POST',
 body: form,
 headers: {
 Accept: "application/json",
    "Content-Type": "multipart/form-data"
  },
})

Begitu juga, anda boleh menggunakan bekas docker llama.cpp atau Ollama untuk menjalankan API tempatan untuk model LLM anda seperti Llama 3.

Jika anda bekerja dengan pasukan ML yang melatih model mereka sendiri atau anda ingin mengehoskan mana-mana model dari Huggingface dan menggunakan pendekatan bekas Docker yang sama, anda juga boleh menyemak cog dengan Replicate. Ia membalut Docker dan direka khusus untuk mencipta bekas Docker untuk model ML.

Semua ini berfungsi dengan baik jika anda mempunyai luas permukaan tugas yang agak kecil yang ingin anda laksanakan dan kebolehkomposisiannya terhad.

Perpustakaan asli JavaScript

Kini yang ini mungkin pilihan yang paling jelas tetapi pilihan terbaik kekal memilih perpustakaan atau alat yang ditulis secara asli dalam JavaScript atau TypeScript dan mujurlah, ekosistem ini terus berkembang.

Kebanyakan penyedia model API awan menawarkan SDK asli JavaScript termasuk. OpenAI, Anthropic dan Google.

Selain itu, dua daripada rangka kerja LLM sumber terbuka yang paling popular iaitu Langchain dan LlamaIndex menyediakan versi TypeScript bagi rangka kerja mereka. Vercel juga menawarkan ai SDK yang dibina dari bawah ke atas dengan fokus yang lebih kukuh untuk menghimpunkan LLM dan pengalaman bahagian hadapan yang mereka kuasai. Walaupun dokumentasi sangat tertumpu pada rangka kerja Next.js Vercel sendiri, SDK juga berfungsi dengan rangka kerja lain.

import { openai } from '@ai-sdk/openai';
import { generateText } from 'ai';

const { text } = await generateText({
 model: openai('gpt-4o'),
 prompt: 'Write a vegetarian lasagna recipe for 4 people.',
});

Walau bagaimanapun, memandangkan kebanyakan alat dan rangka kerja ini akhirnya membungkus alat dan rangka kerja lain sebagai penyepaduan, anda masih sering ditinggalkan dengan fungsi yang lebih terhad daripada rakan Python mereka. Sebagai contoh, versi Python Langchain mempunyai 18 penyepaduan pengubah dokumen yang berbeza manakala JavaScript mempunyai 5.

API LLM asli

Kini yang ini masih lebih berpandangan ke hadapan. Google Chrome baru-baru ini mengeluarkan set percubaan API ke dalam Chrome Dev dan saluran Chrome Canary yang mendedahkan akses kepada model Gemini Nano yang dikendalikan secara tempatan.

const session = await window.ai.createTextSession();
await session.prompt("Translate the following to German: Hello how are you?")
// " Hallo, wie gehts"

Memandangkan model ini sangat kecil berbanding model tercanggih termasuk model yang lebih kecil seperti GPT-4o mini atau Llama 3.1 8B, anda mungkin akan mengalami masa yang lebih sukar untuk menggesanya dengan pasti. Dengan kadar pembangunan model, ini mungkin akan berubah dengan cepat walaupun.

While this API is still experimental and only spearheaded by Chrome, the trend of local LLMs might change this quickly as more companies get interested. Mozilla, for example, recently announced that they are focused on moving "local AI" forward incl. creating a new dedicated accelerator program and Apple is already using local models for their new Apple Intelligence feature.

If you want to give the window.ai API a shot, check out Google's explainer repository as well as the chrome-ai package for Vercel's ai SDK to get started.

Pythonia

One interesting approach to using Python tools in JavaScript is pythonia. It's one half of the JSPyBridge project that creates an interface to call JavaScript from Python and Python from JavaScript by facilitating the interprocess communication so that you can write code in the language of your choice.

It uses inter-process communication (IPC) and JavaScript Proxies to enable you to almost use identical code when calling a Python library in JavaScript than in Python and then actually executing it in Python.

For example, here's a code snippet taken from the getting started guide of the Python library haystack-ai:

from haystack import Pipeline, PredefinedPipeline

pipeline = Pipeline.from_template(PredefinedPipeline.CHAT_WITH_WEBSITE)
result = pipeline.run({
    "fetcher": {"urls": ["https://haystack.deepset.ai/overview/quick-start"]},
    "prompt": {"query": "Which components do I need for a RAG pipeline?"}}
)
print(result["llm"]["replies"][0])

By using the pythonia npm package we can write the same equivalent code:

import { python } from "pythonia";

const haystack = await python("haystack");
const { Pipeline, PredefinedPipeline } = await haystack;

const template = await PredefinedPipeline("chat_with_website");
const pipeline = await Pipeline.from_template(template);
const result = await pipeline.run({
 fetcher: { urls: ["https://haystack.deepset.ai/overview/quick-start"] },
 prompt: { query: "Which components do I need for a RAG pipeline?" },
});

console.log((await result.valueOf()).llm.replies[0]);
python.exit();

You might notice that this code is slightly longer and heavily uses await. That's because of the IPC communication. pythonia does a lot of optimizations behind the scenes to effectively communicate between the channels. For example, the actual data is not being sent back from Python to Node.js unless you call valueOf(). However, outside of that the code is very similar and is using native Python libraries.

Performance of pythoia

One concern for you might be performance and while it would be slower than entirely running in Python, the actual performance might surprise you. If you want to use a Python library, like RAGatoille, but the rest of your system is written in JavaScript, really the only alternative to pythonia is exposing the library through an HTTP API and using fetch to bridge the systems.

If we run a benchmark where we use the haystack-ai code snippet from above and run it both using pythonia and expose it using FastAPI, both requests are slow because of their calls to OpenAI but pythonia actually slightly wins the race.

Using `pythonia` results in an average of 13% faster results but both take longer than 1.2s per run

Overall while there is a performance hit of using pythonia over using only native Python, given the long-running nature of most generative AI calls, the overhead becomes relatively negligible especially when compared to making local HTTP requests.

Conclusion

While more and more JavaScript developers are getting into the Generative AI space, we still have ways to go to catch up to an ecosystem that has the breadth of the Python space. Cloud APIs, running local Docker containers, and bridging projects such as pythonia are great options to tap into this space without moving all of your logic into Python. Ultimately it's up to us though to either grow the space of available AI JavaScript tools by contributing to existing open-source projects or even starting new ones if you want to maintain a project. In the meantime, AI tools such as GitHub Copilot, Cursor, or Codeium can help you with writing some Python code.

Atas ialah kandungan terperinci Lima cara untuk menggunakan Generative AI dalam JavaScript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!