Memulai Valkey menggunakan JavaScript – Beragampengetahuan

Valkey adalah alternatif sumber terbuka untuk Redis. Ini adalah proyek Linux Foundation berbasis komunitas yang bertujuan untuk menjaga proyek tetap tersedia untuk digunakan dan didistribusikan di bawah lisensi 3-klausul Berkeley Software Distribution (BSD) open source setelah perubahan pada lisensi Redis.

Saya rasa postingan blog perdana ini merangkum perjalanan menuju Valkey dengan cukup baik:

Saya akan membahas cara menggunakan Valkey dengan aplikasi JavaScript menggunakan klien yang ada di ekosistem Redis serta iovalkey (fork ramah ioredis).

Gunakan Valkey dengan node-redis

node-redis adalah klien yang populer dan banyak digunakan. Di bawah ini adalah program sederhana yang menggunakan komponen Pelanggan dari API PubSub untuk berlangganan saluran.

import redis from 'redis';

const client = redis.createClient();
const channelName="valkey-channel";

(async () => {
  try {
    await client.connect();
    console.log('Connected to Redis server');

    await client.subscribe(channelName, (message, channel) => {
      console.log(`message "${message}" received from channel "${channel}"`)
    });

    console.log('Waiting for messages...');
  } catch (err) {
    console.error('Error:', err);
  }
})();

Untuk mencobanya dengan Valkey, mari luncurkan sebuah instance menggunakan image Valkey Docker:

docker run --rm -p 6379:637 valkey/valkey

Kunjungi juga distro khusus OS, atau gunakan Homebrew (di Mac) – brew install valkey. Anda sekarang seharusnya dapat menggunakan Valkey CLI (valkey-cli).

Dapatkan kode dari repositori GitHub:

git clone 
cd valkey-javascript

npm install

Mulai aplikasi pelanggan:

node subscriber.js

Publikasikan pesan dan pastikan pelanggan dapat menerimanya:

valkey-cli PUBLISH valkey-channel 'hello valkey'

OKE! Kami dapat menulis aplikasi sederhana menggunakan klien Redis yang sudah ada dan menjalankannya menggunakan Valkey (bukan Redis). Tentu saja, ini adalah contoh yang terlalu disederhanakan, tetapi tidak diperlukan perubahan kode.

Gunakan Valkey dengan ioredis klien

ioredis adalah klien populer lainnya. Agar lebih yakin, yuk kita coba ioredis Hal yang sama berlaku untuk Valkyrie. Mari kita menulis aplikasi penerbit:

import Redis from 'ioredis';

const redisClient = new Redis();
const channelName="valkey-channel";

const message = process.argv[2];

if (!message) {
  console.error('Please provide a message to publish.');
  process.exit(1);
}

async function publishMessage() {
  try {
    const receivedCount = await redisClient.publish(channelName, message);
    console.log(`Message "${message}" published to channel "${channelName}". Received by ${receivedCount} subscriber(s).`);
  } catch (err) {
    console.error('Error publishing message:', err);
  } finally {
    // Close the client connection
    await redisClient.quit();
  }
}

publishMessage();

Jalankan penerbit dan konfirmasikan bahwa aplikasi pelanggan dapat menerimanya:

node publisher.js 'hello1'
node publisher.js 'hello2'

Anda akan melihat log ini di aplikasi pelanggan Anda:

message "hello1" received from channel "valkey-channel"
message "hello2" received from channel "valkey-channel"

beralih ke iovalkey klien

Seperti disebutkan di atas, iovalkey adalah garpu ioredis. Saya membuat perubahan berikut pada port kode produser yang akan digunakan iovalkey:

1. Berkomentar import Redis from 'ioredis';
2. Tambahkan import Redis from 'iovalkey';
3. Dipasang iovalkey – npm install iovalkey

Ini versi terbarunya – ya, hanya itu yang perlu saya ubah (setidaknya untuk aplikasi sederhana ini):

// import Redis from 'ioredis';
import Redis from 'iovalkey';

menjalankan yang baru iovalkey Berdasarkan penerbit dan mengonfirmasi bahwa pelanggan dapat menerimanya:

node publisher.js 'hello from iovalkey'

Anda akan melihat log ini di aplikasi pelanggan Anda:

message "hello from iovalkey" received from channel "valkey-channel"

Luar biasa, semuanya berjalan baik. Kami sekarang siap menerapkan AI generatif!

Menggunakan Valkey dengan LangChainJS

Selain Python, JavaScript/TypeScript juga digunakan untuk menghasilkan ekosistem kecerdasan buatan. LangChain adalah kerangka kerja populer untuk mengembangkan aplikasi yang didorong oleh model bahasa besar (LLM). LangChain menyediakan dukungan JS/TS dalam bentuk LangchainJS.

Setelah banyak bekerja dengan port Go (langchaingo) dan Python, saya ingin mencoba LangchainJS.

Salah satu kasus penggunaan yang umum adalah penggunaan Redis sebagai komponen riwayat obrolan dalam aplikasi AI generatif. LangchainJS memiliki fungsi bawaan ini, jadi mari kita mencobanya dengan Valkey.

Menggunakan Valkey sebagai riwayat obrolan LangChain

Instal LangchainJS:

npm install langchain

Untuk LLM, saya akan menggunakan Amazon Bedrock (didukung secara asli oleh LangchainJS), namun jangan ragu untuk menggunakan bahasa lain.

Untuk Amazon Bedrock, Anda perlu mengonfigurasi dan menyiapkan Amazon Bedrock, termasuk meminta akses ke model yang mendasarinya.

Ini adalah aplikasi obrolan. Seperti yang Anda lihat, itu digunakan RedisChatMessageHistory Elemen.

import { BedrockChat } from "@langchain/community/chat_models/bedrock";
import { RedisChatMessageHistory } from "@langchain/redis";
import { ConversationChain } from "langchain/chains";
import { BufferMemory } from "langchain/memory";
import prompt from "prompt";

import {
  ChatPromptTemplate,
  MessagesPlaceholder,
} from "@langchain/core/prompts";

const chatPrompt = ChatPromptTemplate.fromMessages([
  [
    "system",
    "The following is a friendly conversation between a human and an AI.",
  ],
  new MessagesPlaceholder("chat_history"),
  ["human", "{input}"],
]);

const memory = new BufferMemory({
  chatHistory: new RedisChatMessageHistory({
    sessionId: new Date().toISOString(),
    sessionTTL: 300,
    host: "localhost",
    port: 6379,
  }),
  returnMessages: true,
  memoryKey: "chat_history",
});

const model = "anthropic.claude-3-sonnet-20240229-v1:0"
const region = "us-east-1"

const langchainBedrockChatModel = new BedrockChat({
  model: model,
  region: region,
  modelKwargs: {
    anthropic_version: "bedrock-2023-05-31",
  },
});

const chain = new ConversationChain({
   llm: langchainBedrockChatModel,
   memory: memory,
   prompt: chatPrompt,
});


while (true) {
  prompt.start({noHandleSIGINT: true});
  const {message} = await prompt.get(['message']);
  const response = await chain.invoke({
    input: message,
  });
  console.log(response);

Jalankan aplikasi:

node chat.js

Mulai percakapan:

Jika Anda melihat Valkey, perhatikan bahwa percakapan disimpan di List:

valkey-cli keys *
valkey-cli LRANGE <enter list name> 0 -1

Jangan larikeys * Dalam produksi – hanya untuk tujuan demonstrasi.

menggunakan iovalkey Implementasi catatan obrolan

Implementasi saat ini menggunakan node-redis klien tetapi saya ingin mencobanya iovalkey klien. Saya bukan ahli JS/TS, tetapi mem-porting implementasi yang sudah ada itu sederhana. Anda dapat merujuk ke kode di GitHub

Sejauh menyangkut aplikasi klien (obrolan), saya hanya perlu membuat beberapa perubahan untuk mengalihkan implementasinya:

• Beri komentar import { RedisChatMessageHistory } from "@langchain/redis";
• Tambahkan import { ValkeyChatMessageHistory } from "./valkey_chat_history.js";
• mengganti RedisChatMessageHistory Dan ValkeyChatMessageHistory (Saat membuat memory Contoh)

Cara kerjanya sama seperti di atas. Silakan mencobanya!

bungkus

Ini masih awal bagi Valkey (pada saat penulisan artikel ini) dan jalan yang harus ditempuh masih panjang. Saya tertarik dengan pengembangan proyek dan ekosistem klien Valkey.

Selamat membangun!