Chatbot

Chatbot

A chatbot is a computer program or an artificial intelligence which conducts a conversation via auditory or textual methods

Chatbot-ui: A ChatGPT Clone for Running Locally in Your Browser

Chatbot UI

Note: Chatbot UI Pro has been renamed to Chatbot UI.

Chatbot UI is an advanced chatbot kit for OpenAI's chat models built on top of Chatbot UI Lite using Next.js, TypeScript, and Tailwind CSS.

It aims to mimic ChatGPT's interface and functionality.

All conversations are stored locally on your device.

See a demo.

Chatbot UI

Updates

Chatbot UI will be updated over time.

Expect frequent improvements.

Next up:

  •  More custom model settings
  •  Regenerate & edit responses
  •  Saving via data export
  •  Folders
  •  Prompt templates

Recent updates:

  •  Custom system prompt (3/21/23)
  •  Error handling (3/20/23)
  •  GPT-4 support (access required) (3/20/23)
  •  Search conversations (3/19/23)
  •  Code syntax highlighting (3/18/23)
  •  Toggle sidebar (3/18/23)
  •  Conversation naming (3/18/23)
  •  Github flavored markdown (3/18/23)
  •  Add OpenAI API key in app (3/18/23)
  •  Markdown support (3/17/23)

Modifications

Modify the chat interface in components/Chat.

Modify the sidebar interface in components/Sidebar.

Modify the system prompt in utils/index.ts.

Deploy

Vercel

Host your own live version of Chatbot UI with Vercel.

Deploy with Vercel

Replit

Fork Chatbot UI on Replit here.

Docker

docker build -t chatgpt-ui .
docker run -e OPENAI_API_KEY=xxxxxxxx -p 3000:3000 chatgpt-ui

Running Locally

1. Clone Repo

git clone https://github.com/mckaywrigley/chatbot-ui.git

2. Install Dependencies

npm i

3. Provide OpenAI API Key

Create a .env.local file in the root of the repo with your OpenAI API Key:

OPENAI_API_KEY=YOUR_KEY

4. Run App

npm run dev

5. Use It

You should be able to start chatting.

Contact

If you have any questions, feel free to reach out to me on Twitter.


Download Details:

Author: Mckaywrigley
Source Code: https://github.com/mckaywrigley/chatbot-ui 
License: MIT license

#chatgpt #chatbot #ui #typescript #tailwind #css #openai 

Chatbot-ui: A ChatGPT Clone for Running Locally in Your Browser

Alpaca-LoRA-Serve: Alpaca-LoRA as Chatbot service

Alpaca-LoRA as a Chatbot Service

This repository demonstrates Alpaca-LoRA as a Chatbot service with Alpaca-LoRA and Gradio. It comes with the following features:

The easiest way to run this project is to use Colab. Just open up the alpaca_lora_in_colab notebook in Colab (there is a button open in colab), and run every cell sequentially. With the standard GPU instance(T4), you can run 7B and 13B models. With the premium GPU instance(A100 40GB), you can even run 30B model! Screenshot👇🏼

Mode

1. Batch Generation Mode: batch generation mode aggregates requests up to batch_size, and pass the prompts in the requests to the model. It waits the current requests are fully handled. For instance, with batch_size=4, if a user sends a request, that is under processing. While it is under processing, if other users are connected, up to 4 requests from the users are aggregated and processed as soon as the current one is done.

2. Streaming Mode: streaming mode handles multiple requests in a interleaving way with threads. For instance, if there are two users (A and B) are connected, A's request is handled, and then B's request is handled, and then A's request is handled again.... This is because of the nature of streaming mode which generates and yield tokens in one by one manner.

Context management

  • Alpaca-LoRA as a Chatbot Service manages context in two ways. First of all, it remembers(stores) every history of the conversations by default as in the following code snippet. context_string is set as "Below is a history of instructions that describe tasks, paired with an input that provides further context. Write a response that appropriately completes the request by remembering the conversation history." by default, but it could be set manually via the Context field on top of the screen.
    • additionall, there is a Summarize button in the middle (you need to expand the component labeled as "Helper Buttons"). If you click this button, it automatically input "summarize our conversations so far in three sentences." as a prompt, and the resulting generated text will be inserted into the Context field. THen all the conversation history up to this point will be ignored. That means the conversation fresh restarts with the below code snippet except context_string will be filled up with the model generated text.
f"""{context_string}

### Input: {input} # Surrounding information to AI

### Instruction: {prompt1} # First instruction/prompt given by user

### Response {response1} # First response on the first prompt by AI

### Instruction: {prompt2} # Second instruction/prompt given by user

### Response: {response2} # Second response on the first prompt by AI
....
"""

misc.

  • There is a continue button in the middle of screen. What it does is to simply send "continue." prompt to the model. This is useful if you get incomplete previous response from the model. With the "continue.", the model tries to complete the response. Also, since this is a continuation of the response, the "continue." prompt will be hidden to make chatting history more natural.

Currently supported LoRA checkpoints

Instructions

  • Prerequisites

Note that the code only works Python >= 3.9

$ conda create -n alpaca-serve python=3.9
$ conda activate alpaca-serve
  • Install dependencies
$ cd Alpaca-LoRA-Serve
$ pip install -r requirements.txt
  • Run Gradio application
$ BASE_URL=decapoda-research/llama-7b-hf
$ FINETUNED_CKPT_URL=tloen/alpaca-lora-7b

$ python app.py --base_url $BASE_URL --ft_ckpt_url $FINETUNED_CKPT_URL --port 6006

the following flags are supported

usage: app.py [-h] [--base_url BASE_URL] [--ft_ckpt_url FT_CKPT_URL] [--port PORT] [--batch_size BATCH_SIZE]
              [--api_open API_OPEN] [--share SHARE] [--gen_config_path GEN_CONFIG_PATH]

Gradio Application for Alpaca-LoRA as a chatbot service

optional arguments:
  -h, --help            show this help message and exit
  --base_url BASE_URL   Hugging Face Hub url
  --ft_ckpt_url FT_CKPT_URL
                        Hugging Face Hub url
  --port PORT           port to serve app
  --batch_size BATCH_SIZE
                        how many requests to handle at the same time
                        default is set to 1 which enables streaming mode
  --api_open API_OPEN   do you want to open as API
  --share SHARE         do you want to share temporarily
  --gen_config_path GEN_CONFIG_PATH
                        which config to use for GenerationConfig

Design figure

Acknowledgements

I am thankful to Jarvislabs.ai who generously provided free GPU resources to experiment with Alpaca-LoRA deployment and share it to communities to try out.


Download Details:

Author: Deep-diver
Source Code: https://github.com/deep-diver/Alpaca-LoRA-Serve 
License: Apache-2.0 license

#python #chatbot #service 

Alpaca-LoRA-Serve: Alpaca-LoRA as Chatbot service
Duong Tran

Duong Tran

1679412016

Cách tạo ứng dụng ChatGPT không có máy chủ với Rust

Tìm hiểu cách tạo Ứng dụng ChatGPT không có máy chủ với Rust. Tạo bot GitHub không có máy chủ. Bot là một chức năng không có máy chủ được viết bằng Rust. Bot cho phép người dùng GitHub trò chuyện với ChatGPT và với nhau trong các vấn đề của GitHub. 

Kể từ khi OpenAI phát hành API chính thức cho ChatGPT vào tháng 3 năm 2023, nhiều nhà phát triển và doanh nhân quan tâm đến việc tích hợp nó vào hoạt động kinh doanh của riêng họ.

Nhưng vẫn còn một số rào cản đáng kể khiến họ khó thực hiện điều này:

  • OpenAI cung cấp API phi trạng thái đơn giản cho ChatGPT. Nhà phát triển cần theo dõi lịch sử và ngữ cảnh của từng cuộc hội thoại trong bộ đệm hoặc cơ sở dữ liệu do ứng dụng quản lý. Nhà phát triển cũng cần quản lý và bảo vệ các khóa API. Có rất nhiều mã soạn sẵn không liên quan đến logic nghiệp vụ của ứng dụng.
  • Giao diện người dùng “tự nhiên” cho ứng dụng API ChatGPT là một cuộc trò chuyện theo chuỗi. Nhưng rất khó để tạo “giao diện người dùng trò chuyện” trong khung ứng dụng hoặc web truyền thống. Trên thực tế, giao diện người dùng trò chuyện được sử dụng phổ biến nhất đã tồn tại trong các ứng dụng nhắn tin như Slack, Discord và thậm chí cả các diễn đàn (ví dụ: Thảo luận GitHub). Chúng tôi cần một cách đơn giản để kết nối phản hồi API ChatGPT với dịch vụ nhắn tin hiện có.

Trong bài viết này, tôi sẽ chỉ cho bạn cách tạo bot GitHub không có máy chủ. Bot cho phép người dùng GitHub trò chuyện với ChatGPT và với nhau trong các vấn đề của GitHub. Bạn có thể thử bằng cách đặt câu hỏi hoặc tham gia chuỗi hội thoại khác bằng cách để lại nhận xét. Nói cách khác, dự án này sử dụng giao diện người dùng tin nhắn theo luồng của Vấn đề GitHub làm giao diện người dùng trò chuyện của riêng nó.

7eWhQ8I

Hình 1. Học Rust với ChatGPT. xem https://github.com/second-state/chat-with-chatgpt/issues/31

Bot là một chức năng không có máy chủ được viết bằng Rust. Chỉ cần rẽ nhánh ví dụ, triển khai rẽ nhánh của bạn trênflow.network định cấu hình nó để tương tác với các kho lưu trữ GitHub và khóa OpenAI của riêng bạn. Bạn sẽ có một bot GitHub đầy đủ chức năng sau 10 phút. Không cần thiết lập máy chủ web hoặc webhook cho API GitHub hoặc máy chủ cơ sở dữ liệu/bộ đệm.

Cách rẽ nhánh Repo mẫu

Đầu tiên, rẽ nhánh repo mẫu này từ GitHub .

Tệp src/lib.rschứa ứng dụng bot (còn được gọi là hàm lưu lượng). Chức run()năng được gọi khi khởi động. Nó lắng nghe issue_commentissuescác sự kiện từ repo GitHub owner/repo. Những sự kiện đó được phát ra khi một bình luận vấn đề mới hoặc một vấn đề mới được tạo trong repo.

#[no_mangle]
#[tokio::main(flavor = "current_thread")]
pub async fn run() {
    // Setup variables for
    //   ower: GitHub org to install the bot
    //   repo: GitHub repo to install the bot
    //   openai_key_name: Name for your OpenAI API key
    // All the values can be set in the source code or as env vars
    
    listen_to_event(&owner, &repo, vec!["issue_comment", "issues"], |payload| {
        handler(&owner, &repo, &openai_key_name, payload)
    })
    .await;
}

Hàm handler()xử lý các sự kiện nhận được bởi listen_to_event(). Nếu sự kiện là một bình luận mới trong một vấn đề, thì bot sẽ gọi API ChatGPT của OpenAI để thêm văn bản bình luận vào một cuộc trò chuyện hiện có được xác định bởi issue.number. Nó nhận được phản hồi từ ChatGPT và thêm nhận xét trong vấn đề.

Chức năng luồng ở đây quản lý lịch sử hội thoại một cách tự động và minh bạch bằng API ChatGPT trong bộ nhớ cục bộ. Khóa API OpenAI cũng được lưu trữ trong bộ lưu trữ cục bộ để thay vì đặt văn bản bí mật vào mã nguồn, khóa có thể được xác định bằng tên chuỗi trong tệp openai_key_name.

EventPayload::IssueCommentEvent(e) => {
    if e.comment.user.r#type != "Bot" {
        if let Some(b) = e.comment.body {
            if let Some(r) = chat_completion (
                    openai_key_name,
                    &format!("issue#{}", e.issue.number),
                    &b,
                    &ChatOptions::default(),
            ) {
                if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
                    write_error_log!(e.to_string());
                }
            }
        }
    }
}

Nếu sự kiện là một sự cố mới, chức năng dòng sẽ tạo một cuộc trò chuyện mới được xác định bởi issue.numbervà yêu cầu phản hồi từ ChatGPT.

EventPayload::IssuesEvent(e) => {
    if e.action == IssuesEventAction::Closed {
        return;
    }

    let title = e.issue.title;
    let body = e.issue.body.unwrap_or("".to_string());
    let q = title + "\n" + &body;
    if let Some(r) = chat_completion (
            openai_key_name,
            &format!("issue#{}", e.issue.number),
            &q,
            &ChatOptions::default(),
    ) {
        if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
            write_error_log!(e.to_string());
        }
    }
}

Cách triển khai chức năng Serverless Flow

Như chúng ta có thể thấy, mã chức năng luồng gọi API SDK để thực hiện các hoạt động phức tạp. Ví dụ,

  • Hàm listen_to_event()đăng ký URL webhook thông qua API GitHub để handler()hàm sẽ được gọi khi một số sự kiện nhất định xảy ra trong GitHub.
  • Hàm chat_completion()gọi API ChatGPT với khóa API được đặt tên và lịch sử/bối cảnh trong quá khứ của cuộc trò chuyện đã chỉ định. Khóa API và lịch sử hội thoại được lưu trữ trong bộ đệm Redis.

Máy chủ webhook và bộ đệm Redis đều là các dịch vụ bên ngoài mà SDK phụ thuộc vào. Điều đó có nghĩa là chức năng luồng phải chạy bên trong môi trường máy chủ được quản lý cung cấp các dịch vụ bên ngoài như vậy. Flows.network là máy chủ lưu trữ PaaS (Nền tảng dưới dạng Dịch vụ) dành cho SDK chức năng luồng.

Để triển khai chức năng luồng trênflow.network, bạn chỉ cần nhập mã nguồn của nó vào PaaS.

Trước tiên, hãy đăng nhập vàoflow.network từ tài khoản GitHub của bạn. Nhập repo GitHub rẽ nhánh của bạn có chứa mã nguồn chức năng luồng và chọn "Với biến môi trường".

Lưu ý rằng đây KHÔNG phải là repo GitHub nơi bạn muốn triển khai bot. Đây là repo cho mã nguồn chức năng luồng rẽ nhánh của bạn.

CH1nUf8

Hình 2. Nhập kho lưu trữ GitHub mà bạn đã rẽ nhánh từ mẫu hàm luồng vàoflow.network.

Đặt các biến môi trường để trỏ hàm luồng tới tên khóa API OpenAI ( open_ai_key) và repo GitHub ( ownerrepo).

GitHub ownerrepocác biến ở đây trỏ đến kho lưu trữ GitHub nơi bạn muốn triển khai bot, KHÔNG phải kho lưu trữ cho mã nguồn của hàm luồng.

5gcTKMv

Hình 3. Đặt các biến môi trường cho repo GitHub nơi bạn muốn triển khai bot, cũng như tên khóa API OpenAI.

Flows.network sẽ tìm nạp mã nguồn và xây dựng mã nguồn Rust thành mã byte Wasm bằng cách sử dụng chuỗi cargocông cụ tiêu chuẩn. Sau đó, nó sẽ chạy chức năng luồng Wasm trong Thời gian chạy WasmEdge .

Cách kết nối Flow Function với GitHub và OpenAI

Mặc dù chức năng luồng yêu cầu kết nối với API OpenAI và GitHub, nhưng mã nguồn không có khóa API, mã thông báo truy cập hoặc logic OAUTH được mã hóa cứng. Các SDK chức năng luồng đã giúp các nhà phát triển tương tác với các dịch vụ API SaaS bên ngoài dễ dàng và an toàn.

Flows.network phát hiện ra rằng chức năng luồng yêu cầu kết nối với API OpenAI và GitHub. Nó trình bày quy trình công việc giao diện người dùng để các nhà phát triển:

  • Đăng nhập vào GitHub, cấp quyền truy cập vào các sự kiện và đăng ký chức năng luồng dưới dạng webhook để nhận các sự kiện đó.
  • Liên kết khóa API OpenAI với tên openai_key_name.

CpLDrub

Hình 4. Các dịch vụ bên ngoài theo yêu cầu của chức năng luồng được kết nối và chuyển sang màu xanh lục.

Sau khi các API SaaS bên ngoài được kết nối và ủy quyền, chúng sẽ chuyển sang màu xanh lục trên bảng điều khiển chức năng luồng. Chức năng luồng bây giờ sẽ nhận các sự kiện mà nó listen_to_event()dành cho. Nó cũng sẽ có quyền truy cập minh bạch vào Redis cho khóa API OpenAI được đặt tên và ngữ cảnh hội thoại được lưu trong bộ nhớ cache để hỗ trợ chat_completion()chức năng SDK.

Cái gì tiếp theo

Bot GitHub chỉ là một trong nhiều loại bot màflow.network có thể hỗ trợ. Bằng cách kết nối chức năng luồng với kênh Slack, bạn có thể yêu cầu ChatGPT tham gia vào cuộc thảo luận nhóm của mình. Đây là một ví dụ về bot ChatGPT dựa trên Slack.

GitHub - mạng lưu lượng/trò chuyện cộng tác

biểu tượng yêu thíchluồng-mạngGitHub

cộng tác-trò chuyện

https://github.com/flows-network/collaborative-chatvoB27bjHình 5. Bot Slack ChatGPT.

Một ví dụ khác là để ChatGPT trả lời các câu hỏi pháp lý trong kênh Slack. Hàm quy trình đặt trước câu hỏi pháp lý bằng lời nhắc.

GitHub - mạng lưu lượng/robo-luật sư

biểu tượng yêu thíchluồng-mạngGitHub

luật sư người máy

https://github.com/flows-network/robo-lawyerafDM5imHình 6. Bot luật sư người máy Slack.

Bên cạnh GitHub và Slack, có nhiều sản phẩm SaaS mà bạn có thể tích hợp vào flow.network thông qua API của chúng.

Mặc dù các chức năng luồng mẫu được viết bằng Rust, nhưng chúng tôi mong muốn hỗ trợ SDK chức năng luồng dựa trên JavaScript. Nói cách khác, các chức năng SDK nền tảng chẳng hạn như listen_to_event()chat_completion()sẽ có phiên bản JavaScript. Hàm luồng JavaScript chạy bên trong Thời gian chạy WasmEdge trên nền tảngflow.network thông qua mô-đun WasmEdge-QuickJS .

Nguồn: https://www.freecodecamp.org

#rust #chatbot #chatgpt

Cách tạo ứng dụng ChatGPT không có máy chủ với Rust

كيفية إنشاء تطبيق ChatGPT بدون خادم مع Rust

تعرف على كيفية إنشاء تطبيق ChatGPT بدون خادم باستخدام Rust. إنشاء روبوت GitHub بدون خادم. الروبوت هو وظيفة بدون خادم مكتوبة بلغة Rust. يسمح الروبوت لمستخدمي GitHub بالدردشة مع ChatGPT ومع بعضهم البعض في مشكلات GitHub. 

منذ أن أصدرت OpenAI واجهة برمجة تطبيقات رسمية لـ ChatGPT في مارس 2023 ، يهتم العديد من المطورين ورجال الأعمال بدمجها في عملياتهم التجارية الخاصة.

لكن لا تزال هناك بعض العوائق المهمة التي تجعل من الصعب عليهم القيام بذلك:

  • يوفر OpenAI واجهة برمجة تطبيقات بسيطة عديمة الحالة لـ ChatGPT. يحتاج المطور إلى تتبع محفوظات وسياق كل محادثة في ذاكرة تخزين مؤقت أو قاعدة بيانات يديرها التطبيق. يحتاج المطور أيضًا إلى إدارة وحماية مفاتيح API. هناك الكثير من التعليمات البرمجية المعيارية لا علاقة لها بمنطق عمل التطبيق.
  • واجهة المستخدم "الطبيعية" لتطبيق ChatGPT API هي دردشة مترابطة. ولكن من الصعب إنشاء "واجهة مستخدم دردشة" في إطار عمل ويب أو تطبيق تقليدي. في الواقع ، توجد واجهة مستخدم الدردشة الأكثر استخدامًا بالفعل في تطبيقات المراسلة مثل Slack و Discord وحتى المنتديات (على سبيل المثال ، GitHub Discussions). نحتاج إلى طريقة بسيطة لربط استجابات ChatGPT API بخدمة مراسلة موجودة.

في هذه المقالة ، سأوضح لك كيفية إنشاء روبوت GitHub بدون خادم. يسمح الروبوت لمستخدمي GitHub بالدردشة مع ChatGPT ومع بعضهم البعض في مشكلات GitHub. يمكنك تجربتها عن طريق طرح سؤال أو الانضمام إلى سلسلة محادثات أخرى عن طريق ترك تعليق. بمعنى آخر ، يستخدم هذا المشروع واجهة مستخدم الرسائل المترابطة الخاصة بـ GitHub Issues كواجهة مستخدم دردشة خاصة به.

7eWhQ8I

الشكل 1. تعلم Rust مع ChatGPT. انظر https://github.com/second-state/chat-with-chatgpt/issues/31

The bot is a serverless function written in Rust. Just fork the example, deploy your fork on flows.network, and configure it to interact with your own GitHub repos and OpenAI keys. You will have a fully functional GitHub bot in 10 minutes. There is no need to set up a web server, or a webhook for GitHub API, or a cache / database server.

How to Fork the Template Repo

First, fork this template repo from GitHub.

The src/lib.rs file contains the bot application (also known as the flow function). The run() function is called upon starting up. It listens for issue_comment and issues events from the GitHub repo owner/repo. Those events are emitted when a new issue comment or a new issue is created in the repo.

#[no_mangle]
#[tokio::main(flavor = "current_thread")]
pub async fn run() {
    // Setup variables for
    //   ower: GitHub org to install the bot
    //   repo: GitHub repo to install the bot
    //   openai_key_name: Name for your OpenAI API key
    // All the values can be set in the source code or as env vars
    
    listen_to_event(&owner, &repo, vec!["issue_comment", "issues"], |payload| {
        handler(&owner, &repo, &openai_key_name, payload)
    })
    .await;
}

The handler() function processes the events received by listen_to_event(). If the event is a new comment in an issue, the bot calls OpenAI's ChatGPT API to add the comment text into an existing conversation identified by the issue.number. It receives a response from ChatGPT, and adds a comment in the issue.

The flow function here automatically and transparently manages the conversation history with the ChatGPT API in a local storage. The OpenAI API key is also stored in the local storage so that instead of putting the secret text in the source code, the key can be identified by a string name in openai_key_name.

EventPayload::IssueCommentEvent(e) => {
    if e.comment.user.r#type != "Bot" {
        if let Some(b) = e.comment.body {
            if let Some(r) = chat_completion (
                    openai_key_name,
                    &format!("issue#{}", e.issue.number),
                    &b,
                    &ChatOptions::default(),
            ) {
                if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
                    write_error_log!(e.to_string());
                }
            }
        }
    }
}

If the event is a new issue, the flow function creates a new conversation identified by issue.number, and requests a response from ChatGPT.

EventPayload::IssuesEvent(e) => {
    if e.action == IssuesEventAction::Closed {
        return;
    }

    let title = e.issue.title;
    let body = e.issue.body.unwrap_or("".to_string());
    let q = title + "\n" + &body;
    if let Some(r) = chat_completion (
            openai_key_name,
            &format!("issue#{}", e.issue.number),
            &q,
            &ChatOptions::default(),
    ) {
        if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
            write_error_log!(e.to_string());
        }
    }
}

How to Deploy the Serverless Flow Function

As we can see, the flow function code calls SDK APIs to perform complex operations. For example,

  • The listen_to_event() function registers a webhook URL through GitHub API so that the handler() function will be called when certain events occur in GitHub.
  • The chat_completion() function calls the ChatGPT API with the named API key and past history / context of the specified conversation. The API key and conversation history are stored in a Redis cache.

The webhook server and the Redis cache are both external services the SDK depends on. That means the flow function must run inside a managed host environment that provides such external services. Flows.network is a PaaS (Platform as a Service) host for the flow function SDKs.

لنشر وظيفة التدفق على flow.network ، تحتاج ببساطة إلى استيراد كود المصدر الخاص به إلى PaaS.

أولاً ، قم بتسجيل الدخول إلى flow.network من حساب GitHub الخاص بك. قم باستيراد مستودع GitHub المتشعب الذي يحتوي على الكود المصدري لوظيفة التدفق واختر "With Environment Variables".

لاحظ أن هذا ليس GitHub repo حيث تريد نشر الروبوت. هذا هو الريبو لكود مصدر وظيفة التدفق المتشعب.

CH1nUf8

الشكل 2. قم باستيراد GitHub repo الذي قمت بتشكيله من قالب وظيفة التدفق إلى flow.network.

قم بتعيين متغيرات البيئة لتوجيه وظيفة التدفق إلى اسم مفتاح OpenAI API ( open_ai_key) و GitHub repo ( ownerو repo).

يشير GitHub ownerوالمتغيرات repoهنا إلى GitHub repo حيث تريد نشر الروبوت ، وليس الريبو لكود مصدر وظيفة التدفق.

5gcTKMv

الشكل 3. قم بتعيين متغيرات البيئة لـ GitHub repo حيث تريد نشر الروبوت ، بالإضافة إلى اسم مفتاح OpenAI API.

سيقوم Flows.network بجلب الكود المصدري وإنشاء كود مصدر Rust في رمز Wasm bytecode باستخدام cargoسلسلة الأدوات القياسية. سيتم بعد ذلك تشغيل وظيفة تدفق Wasm في WasmEdge Runtime .

كيفية توصيل وظيفة التدفق بـ GitHub و OpenAI

بينما تتطلب وظيفة التدفق اتصالات بواجهة برمجة تطبيقات OpenAI و GitHub ، لا تحتوي شفرة المصدر على مفاتيح API مشفرة أو رموز وصول أو منطق OAUTH. جعلت SDKs لوظيفة التدفقات من السهل والآمن للمطورين التفاعل مع خدمات SaaS API الخارجية.

اكتشف Flows.network أن وظيفة التدفق تتطلب اتصالات بواجهات برمجة تطبيقات OpenAI و GitHub. يقدم مهام سير عمل واجهة المستخدم للمطورين من أجل:

  • Log into GitHub, authorize access to events, and register the flow function as the webhook for receiving those events.
  • Associate an OpenAI API key with the name openai_key_name.

CpLDrub

Figure 4. The external services required by the flow function are connected and turned green.

Once the external SaaS APIs are connected and authorized, they turn green on the flow function dashboard. The flow function will now receive the events it listen_to_event() for. It will also get transparent access to Redis for the named OpenAI API key and the cached conversation context to support the chat_completion() SDK function.

What's next

يعد GitHub bot واحدًا فقط من العديد من أنواع الروبوتات التي يمكن أن تدعمها الشبكة. من خلال توصيل وظيفة التدفق بقناة Slack ، يمكنك الحصول على ChatGPT للمشاركة في مناقشة المجموعة الخاصة بك. فيما يلي مثال على روبوت ChatGPT المستند إلى Slack.

GitHub - تدفقات الشبكة / الدردشة التعاونية

الأيقونة المفضلةتدفقات الشبكة

تعاونية الدردشة

https://github.com/flows-network/collaborative-chatvoB27bjالشكل 5. روبوت Slack ChatGPT.

مثال آخر هو جعل ChatGPT يجيب على الأسئلة القانونية في قناة Slack. تقوم وظيفة التدفق بإلحاق السؤال القانوني بموجه.

جيثب - شبكة التدفقات / المحامي الآلي

الأيقونة المفضلةتدفقات الشبكة

محامي آلي

https://github.com/flows-network/robo-lawyerafDM5imالشكل 6. روبوت محامي Slack robo.

إلى جانب GitHub و Slack ، هناك العديد من منتجات SaaS التي يمكنك دمجها في flow.network من خلال واجهات برمجة التطبيقات الخاصة بهم.

بينما تتم كتابة وظائف التدفق النموذجية بلغة Rust ، فإننا نهدف إلى دعم SDK لوظيفة التدفق المستندة إلى JavaScript. بعبارة أخرى ، يعمل النظام الأساسي SDK مثل إصدار JavaScript وسيكون له listen_to_event(). chat_completion()تعمل وظيفة تدفق JavaScript داخل WasmEdge Runtime على منصة flow.network من خلال وحدة WasmEdge-QuickJS .

المصدر: https://www.freecodecamp.org

#rust #chatbot #chatgpt

كيفية إنشاء تطبيق ChatGPT بدون خادم مع Rust

Como criar um aplicativo ChatGPT sem servidor com Rust

Aprenda a criar um aplicativo Serverless ChatGPT com Rust. Crie um bot do GitHub sem servidor. O bot é uma função sem servidor escrita em Rust. O bot permite que os usuários do GitHub conversem com o ChatGPT e entre si em Problemas do GitHub. 

Desde que a OpenAI lançou uma API oficial para o ChatGPT em março de 2023, muitos desenvolvedores e empreendedores estão interessados ​​em integrá-la às suas próprias operações comerciais.

Mas permanecem algumas barreiras significativas que dificultam isso:

  • OpenAI fornece uma API simples sem estado para ChatGPT. O desenvolvedor precisa acompanhar o histórico e o contexto de cada conversa em um cache ou banco de dados gerenciado pelo aplicativo. O desenvolvedor também precisa gerenciar e proteger as chaves de API. Há muito código clichê não relacionado à lógica de negócios do aplicativo.
  • A interface do usuário “natural” para o aplicativo ChatGPT API é um bate-papo encadeado. Mas é difícil criar uma “IU de bate-papo” em uma estrutura tradicional da Web ou de um aplicativo. Na verdade, a interface do usuário de bate-papo mais usada já existe em aplicativos de mensagens como Slack, Discord e até mesmo em fóruns (por exemplo, GitHub Discussions). Precisamos de uma maneira simples de conectar as respostas da API do ChatGPT a um serviço de mensagens existente.

Neste artigo, mostrarei como criar um bot do GitHub sem servidor. O bot permite que os usuários do GitHub conversem com o ChatGPT e entre si em Problemas do GitHub. Você pode tentar fazendo uma pergunta ou entrar em outro tópico de conversa deixando um comentário. Em outras palavras, este projeto usa a interface do usuário de mensagens encadeadas do GitHub Issues como sua própria interface do usuário de bate-papo.

7eWhQ8I

Figura 1. Aprendendo Rust com ChatGPT. consulte https://github.com/second-state/chat-with-chatgpt/issues/31

O bot é uma função sem servidor escrita em Rust. Basta bifurcar o exemplo, implantar sua bifurcação em flows.network e configurá-lo para interagir com seus próprios repositórios GitHub e chaves OpenAI. Você terá um bot do GitHub totalmente funcional em 10 minutos. Não há necessidade de configurar um servidor web, ou um webhook para GitHub API, ou um cache/servidor de banco de dados.

Como bifurcar o repositório de modelos

Primeiro, bifurque este repositório de modelos do GitHub .

O src/lib.rsarquivo contém o aplicativo bot (também conhecido como função de fluxo). A run()função é chamada na inicialização. Ele escuta issue_commente issueseventos do repositório GitHub owner/repo. Esses eventos são emitidos quando um novo comentário de problema ou um novo problema é criado no repositório.

#[no_mangle]
#[tokio::main(flavor = "current_thread")]
pub async fn run() {
    // Setup variables for
    //   ower: GitHub org to install the bot
    //   repo: GitHub repo to install the bot
    //   openai_key_name: Name for your OpenAI API key
    // All the values can be set in the source code or as env vars
    
    listen_to_event(&owner, &repo, vec!["issue_comment", "issues"], |payload| {
        handler(&owner, &repo, &openai_key_name, payload)
    })
    .await;
}

A handler()função processa os eventos recebidos por listen_to_event(). Se o evento for um novo comentário em um problema, o bot chama a API ChatGPT da OpenAI para adicionar o texto do comentário a uma conversa existente identificada pelo issue.number. Ele recebe uma resposta do ChatGPT e adiciona um comentário no problema.

A função de fluxo aqui gerencia de forma automática e transparente o histórico de conversas com a API ChatGPT em um armazenamento local. A chave da API OpenAI também é armazenada no armazenamento local para que, em vez de colocar o texto secreto no código-fonte, a chave possa ser identificada por um nome de string em openai_key_name.

EventPayload::IssueCommentEvent(e) => {
    if e.comment.user.r#type != "Bot" {
        if let Some(b) = e.comment.body {
            if let Some(r) = chat_completion (
                    openai_key_name,
                    &format!("issue#{}", e.issue.number),
                    &b,
                    &ChatOptions::default(),
            ) {
                if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
                    write_error_log!(e.to_string());
                }
            }
        }
    }
}

Se o evento for um novo problema, a função de fluxo cria uma nova conversa identificada por issue.numbere solicita uma resposta do ChatGPT.

EventPayload::IssuesEvent(e) => {
    if e.action == IssuesEventAction::Closed {
        return;
    }

    let title = e.issue.title;
    let body = e.issue.body.unwrap_or("".to_string());
    let q = title + "\n" + &body;
    if let Some(r) = chat_completion (
            openai_key_name,
            &format!("issue#{}", e.issue.number),
            &q,
            &ChatOptions::default(),
    ) {
        if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
            write_error_log!(e.to_string());
        }
    }
}

Como implantar a função de fluxo sem servidor

Como podemos ver, o código da função de fluxo chama as APIs do SDK para executar operações complexas. Por exemplo,

  • A listen_to_event()função registra uma URL de webhook por meio da API do GitHub para que a handler()função seja chamada quando determinados eventos ocorrerem no GitHub.
  • A chat_completion()função chama a API ChatGPT com a chave de API nomeada e o histórico/contexto passado da conversa especificada. A chave de API e o histórico de conversas são armazenados em um cache Redis.

O servidor webhook e o cache Redis são serviços externos dos quais o SDK depende. Isso significa que a função de fluxo deve ser executada dentro de um ambiente de host gerenciado que forneça tais serviços externos. Flows.network é um host PaaS (Platform as a Service) para os SDKs de função de fluxo.

Para implantar a função de fluxo em flows.network, basta importar seu código-fonte para o PaaS.

Primeiro, entre em flows.network de sua conta do GitHub. Importe seu repositório bifurcado do GitHub que contém o código-fonte da função de fluxo e escolha "Com variáveis ​​de ambiente".

Observe que este NÃO é o repositório do GitHub onde você deseja implantar o bot. Este é o repositório do código-fonte da função de fluxo bifurcado.

CH1nUf8

Figura 2. Importe o repositório do GitHub que você bifurcou do modelo de função de fluxo para o flows.network.

Defina as variáveis ​​de ambiente para apontar a função de fluxo para o nome da chave API OpenAI ( open_ai_key) e o repositório GitHub ( ownere repo).

O GitHub ownere repoas variáveis ​​aqui apontam para o repositório GitHub onde você deseja implantar o bot, NÃO o repositório para o código-fonte da função de fluxo.

5gcTKMv

Figura 3. Defina as variáveis ​​de ambiente para o repositório GitHub no qual você deseja implantar o bot, bem como o nome da chave da API OpenAI.

Flows.network buscará o código-fonte e construirá o código-fonte Rust no bytecode Wasm usando a cadeia cargode ferramentas padrão. Em seguida, ele executará a função Wasm flow no WasmEdge Runtime .

Como conectar a função Flow ao GitHub e OpenAI

Embora a função de fluxo exija conexões com as APIs OpenAI e GitHub, o código-fonte não possui chaves de API codificadas, tokens de acesso ou lógica OAUTH. Os SDKs de função de fluxo tornaram mais fácil e seguro para os desenvolvedores interagir com serviços externos de API SaaS.

Flows.network descobre que a função de fluxo requer conexões com as APIs OpenAI e GitHub. Ele apresenta fluxos de trabalho de interface do usuário para os desenvolvedores:

  • Faça login no GitHub, autorize o acesso aos eventos e registre a função de fluxo como o webhook para receber esses eventos.
  • Associe uma chave de API OpenAI ao nome openai_key_name.

CpLDrub

Figura 4. Os serviços externos requeridos pela função de fluxo são conectados e ficam verdes.

Depois que as APIs SaaS externas são conectadas e autorizadas, elas ficam verdes no painel de função de fluxo. A função de fluxo agora receberá os eventos listen_to_event()para os quais. Ele também obterá acesso transparente ao Redis para a chave de API OpenAI nomeada e o contexto de conversa em cache para oferecer suporte à chat_completion()função SDK.

Qual é o próximo

O bot do GitHub é apenas um dos muitos tipos de bot que o flows.network pode suportar. Ao conectar a função de fluxo a um canal do Slack, você pode fazer com que o ChatGPT participe de sua discussão em grupo. Aqui está um exemplo de um bot ChatGPT baseado em Slack.

GitHub - rede de fluxos/bate-papo colaborativo

faviconflow-networkGitHub

bate-papo colaborativo

https://github.com/flows-network/collaborative-chatvoB27bjFigura 5. O bot Slack ChatGPT.

Outro exemplo é ter o ChatGPT respondendo questões jurídicas em um canal do Slack. A função de fluxo precede a pergunta legal com um prompt.

GitHub - rede de fluxos/robô-advogado

faviconflow-networkGitHub

robo-advogado

https://github.com/flows-network/robo-lawyerafDM5imFigura 6. O robô advogado do Slack.

Além do GitHub e do Slack, existem muitos produtos SaaS que você pode integrar ao flows.network por meio de suas APIs.

Embora as funções de fluxo de exemplo sejam escritas em Rust, nosso objetivo é oferecer suporte a SDKs de funções de fluxo baseadas em JavaScript. Em outras palavras, as funções do SDK da plataforma, como listen_to_event()e, chat_completion()terão uma versão JavaScript. A função de fluxo do JavaScript é executada dentro do WasmEdge Runtime na plataforma flows.network por meio do módulo WasmEdge-QuickJS .

Fonte: https://www.freecodecamp.org

#rust #chatbot #chatgpt


 

Como criar um aplicativo ChatGPT sem servidor com Rust
최  호민

최 호민

1679397421

Rust로 서버리스 ChatGPT 앱을 만드는 방법

Rust로 서버리스 ChatGPT 앱을 만드는 방법을 알아보세요. 서버리스 GitHub 봇을 만듭니다. 봇은 Rust로 작성된 서버리스 기능입니다. 봇을 통해 GitHub 사용자는 GitHub 문제에서 ChatGPT 및 서로 채팅할 수 있습니다. 

OpenAI가 2023년 3월에 ChatGPT용 공식 API를 출시한 이후 많은 개발자와 기업가가 이를 자체 비즈니스 운영에 통합하는 데 관심을 갖고 있습니다.

그러나 이러한 작업을 수행하기 어렵게 만드는 몇 가지 중요한 장벽이 남아 있습니다.

  • OpenAI는 ChatGPT를 위한 간단한 상태 비저장 API를 제공합니다 . 개발자는 애플리케이션에서 관리하는 캐시 또는 데이터베이스에서 각 대화의 기록과 컨텍스트를 추적해야 합니다. 개발자는 또한 API 키를 관리하고 보호해야 합니다. 애플리케이션의 비즈니스 로직과 관련이 없는 상용구 코드가 많이 있습니다.
  • ChatGPT API 애플리케이션의 "자연스러운" UI는 스레드 채팅입니다. 하지만 전통적인 웹이나 앱 프레임워크에서 "채팅 UI"를 만드는 것은 어렵습니다. 실제로 가장 일반적으로 사용되는 채팅 UI는 Slack, Discord, 심지어 포럼(예: GitHub 토론)과 같은 메시징 앱에 이미 존재합니다. ChatGPT API 응답을 기존 메시징 서비스에 연결하는 간단한 방법이 필요합니다.

이 기사에서는 서버리스 GitHub 봇을 만드는 방법을 보여드리겠습니다. 봇을 통해 GitHub 사용자는 GitHub 문제에서 ChatGPT 및 서로 채팅할 수 있습니다. 질문을 하거나 댓글을 남겨 다른 대화 스레드에 참여하여 시도 할 수 있습니다 . 즉, 이 프로젝트는 GitHub Issues의 스레드된 메시지 UI를 자체 채팅 UI로 사용합니다.

7eWhQ8I

그림 1. ChatGPT로 러스트 학습. https://github.com/second-state/chat-with-chatgpt/issues/31 참조

봇은 Rust로 작성된 서버리스 기능입니다. 예시를 포크하고, flow.network 에 포크를 배포하고 , 자신의 GitHub 리포지토리 및 OpenAI 키와 상호 작용하도록 구성하십시오. 10분 안에 완전히 작동하는 GitHub 봇을 갖게 됩니다. 웹 서버나 GitHub API용 웹후크 또는 캐시/데이터베이스 서버를 설정할 필요가 없습니다.

템플릿 저장소를 포크하는 방법

먼저 GitHub에서 이 템플릿 저장소를 포크합니다 .

파일 src/lib.rs에는 봇 애플리케이션(흐름 함수라고도 함)이 포함되어 있습니다. 함수 run()는 시작할 때 호출됩니다. GitHub repo 에서 이벤트를 issue_comment수신 합니다 . 해당 이벤트는 새 이슈 댓글 또는 새 이슈가 저장소에 생성될 때 발생합니다.issuesowner/repo

#[no_mangle]
#[tokio::main(flavor = "current_thread")]
pub async fn run() {
    // Setup variables for
    //   ower: GitHub org to install the bot
    //   repo: GitHub repo to install the bot
    //   openai_key_name: Name for your OpenAI API key
    // All the values can be set in the source code or as env vars
    
    listen_to_event(&owner, &repo, vec!["issue_comment", "issues"], |payload| {
        handler(&owner, &repo, &openai_key_name, payload)
    })
    .await;
}

The handler() function processes the events received by listen_to_event(). If the event is a new comment in an issue, the bot calls OpenAI's ChatGPT API to add the comment text into an existing conversation identified by the issue.number. It receives a response from ChatGPT, and adds a comment in the issue.

The flow function here automatically and transparently manages the conversation history with the ChatGPT API in a local storage. The OpenAI API key is also stored in the local storage so that instead of putting the secret text in the source code, the key can be identified by a string name in openai_key_name.

EventPayload::IssueCommentEvent(e) => {
    if e.comment.user.r#type != "Bot" {
        if let Some(b) = e.comment.body {
            if let Some(r) = chat_completion (
                    openai_key_name,
                    &format!("issue#{}", e.issue.number),
                    &b,
                    &ChatOptions::default(),
            ) {
                if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
                    write_error_log!(e.to_string());
                }
            }
        }
    }
}

If the event is a new issue, the flow function creates a new conversation identified by issue.number, and requests a response from ChatGPT.

EventPayload::IssuesEvent(e) => {
    if e.action == IssuesEventAction::Closed {
        return;
    }

    let title = e.issue.title;
    let body = e.issue.body.unwrap_or("".to_string());
    let q = title + "\n" + &body;
    if let Some(r) = chat_completion (
            openai_key_name,
            &format!("issue#{}", e.issue.number),
            &q,
            &ChatOptions::default(),
    ) {
        if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
            write_error_log!(e.to_string());
        }
    }
}

How to Deploy the Serverless Flow Function

As we can see, the flow function code calls SDK APIs to perform complex operations. For example,

  • The listen_to_event() function registers a webhook URL through GitHub API so that the handler() function will be called when certain events occur in GitHub.
  • The chat_completion() function calls the ChatGPT API with the named API key and past history / context of the specified conversation. The API key and conversation history are stored in a Redis cache.

The webhook server and the Redis cache are both external services the SDK depends on. That means the flow function must run inside a managed host environment that provides such external services. Flows.network is a PaaS (Platform as a Service) host for the flow function SDKs.

In order to deploy the flow function on flows.network, you simply need to import its source code to the PaaS.

First, sign into flows.network from your GitHub account. Import your forked GitHub repo that contains the flow function source code and choose "With Environment Variables".

Note that this is NOT the GitHub repo where you want to deploy the bot. This is the repo for your forked flow function source code.

CH1nUf8

Figure 2. Import the GitHub repo you forked from the flow function template into flows.network.

Set the environment variables to point the flow function to the OpenAI API key name (open_ai_key) and GitHub repo (owner and repo).

The GitHub owner and repo variables here point to the GitHub repo where you want to deploy the bot, NOT the repo for the flow function source code.

5gcTKMv

그림 3. 봇을 배포하려는 GitHub 리포지토리와 OpenAI API 키 이름에 대한 환경 변수를 설정합니다.

Flows.network는 소스 코드를 가져오고 표준 도구 체인을 사용하여 Rust 소스 코드를 Wasm 바이트코드로 빌드합니다 cargo. 그런 다음 WasmEdge 런타임 에서 Wasm 흐름 기능을 실행합니다 .

Flow 함수를 GitHub 및 OpenAI에 연결하는 방법

흐름 함수에는 OpenAI 및 GitHub API에 대한 연결이 필요하지만 소스 코드에는 하드코딩된 API 키, 액세스 토큰 또는 OAUTH 로직이 없습니다. 흐름 기능 SDK를 사용하면 개발자가 외부 SaaS API 서비스와 쉽고 안전하게 상호 작용할 수 있습니다.

Flows.network는 흐름 함수에 OpenAI 및 GitHub API에 대한 연결이 필요함을 발견합니다. 개발자가 다음을 수행할 수 있는 UI 워크플로를 제공합니다.

  • GitHub에 로그인하고, 이벤트에 대한 액세스 권한을 부여하고, 해당 이벤트를 수신하기 위한 webhook으로 흐름 함수를 등록합니다.
  • OpenAI API 키를 이름과 연결합니다 openai_key_name.

CpLDrub

그림 4. 흐름 기능에 필요한 외부 서비스가 연결되고 녹색으로 바뀝니다.

외부 SaaS API가 연결되고 권한이 부여되면 흐름 기능 대시보드에서 녹색으로 바뀝니다. 흐름 함수는 이제 이벤트를 수신합니다 listen_to_event(). 또한 SDK 기능을 지원하기 위해 명명된 OpenAI API 키 및 캐시된 대화 컨텍스트에 대해 Redis에 투명하게 액세스할 수 있습니다 chat_completion().

무엇 향후 계획

GitHub 봇은 flow.network가 지원할 수 있는 많은 봇 유형 중 하나일 뿐입니다. 흐름 기능을 Slack 채널에 연결하면 ChatGPT가 그룹 토론에 참여할 수 있습니다. 다음은 Slack 기반 ChatGPT 봇의 예입니다.

GitHub - 흐름-네트워크/협업-채팅

파비콘흐름-네트워크GitHub

공동 채팅

https://github.com/flows-network/collaborative-chatvoB27bj그림 5. Slack ChatGPT 봇.

또 다른 예는 Slack 채널에서 ChatGPT가 법적 질문에 답변하도록 하는 것입니다. 흐름 함수는 법적 질문 앞에 프롬프트를 추가합니다.

GitHub - flow-network/로보-변호사

파비콘흐름-네트워크GitHub

로봇 변호사

https://github.com/flows-network/robo-lawyerafDM5im그림 6. Slack 로봇 변호사 봇.

GitHub 및 Slack 외에도 해당 API를 통해 flow.network에 통합할 수 있는 많은 SaaS 제품이 있습니다.

예제 흐름 함수는 Rust로 작성되었지만 JavaScript 기반 흐름 함수 SDK를 지원하는 것을 목표로 합니다. 즉, 와 같은 플랫폼 SDK 기능은 listen_to_event()JavaScript chat_completion()버전을 갖게 됩니다. JavaScript 흐름 함수는 WasmEdge-QuickJS 모듈을 통해 Flows.network 플랫폼의 WasmEdge Runtime 내에서 실행됩니다 .

출처: https://www.freecodecamp.org

#rust #chatbot #chatgpt

Rust로 서버리스 ChatGPT 앱을 만드는 방법

Как создать бессерверное приложение ChatGPT с помощью Rust

Узнайте, как создать бессерверное приложение ChatGPT с помощью Rust. Создайте бессерверного бота GitHub. Бот представляет собой бессерверную функцию, написанную на Rust. Бот позволяет пользователям GitHub общаться с ChatGPT и друг с другом в проблемах GitHub. 

Поскольку OpenAI выпустил официальный API для ChatGPT в марте 2023 года, многие разработчики и предприниматели заинтересованы в его интеграции в свои бизнес-операции.

Но остаются некоторые существенные барьеры, которые мешают им это сделать:

  • OpenAI предоставляет простой API без сохранения состояния для ChatGPT. Разработчик должен отслеживать историю и контекст каждого диалога в кэше или базе данных, управляемой приложением. Разработчик также должен управлять ключами API и защищать их. Существует много шаблонного кода, не связанного с бизнес-логикой приложения.
  • «Естественный» пользовательский интерфейс для приложения ChatGPT API — это многопоточный чат. Но сложно создать «пользовательский интерфейс чата» в традиционном веб-фреймворке или приложении. На самом деле наиболее часто используемый пользовательский интерфейс чата уже существует в таких приложениях для обмена сообщениями, как Slack, Discord и даже на форумах (например, GitHub Discussions). Нам нужен простой способ подключения ответов API ChatGPT к существующей службе обмена сообщениями.

В этой статье я покажу вам, как создать бессерверного бота GitHub. Бот позволяет пользователям GitHub общаться с ChatGPT и друг с другом в проблемах GitHub. Вы можете попробовать это, задав вопрос или присоединившись к другой ветке бесед , оставив комментарий. Другими словами, этот проект использует пользовательский интерфейс цепочек сообщений GitHub Issues в качестве собственного пользовательского интерфейса чата.

7eWhQ8I

Рисунок 1. Изучение Rust с помощью ChatGPT. см. https://github.com/second-state/chat-with-chatgpt/issues/31

Бот представляет собой бессерверную функцию, написанную на Rust. Просто разверните пример, разверните свой форк на потоках.network и настройте его для взаимодействия с вашими собственными репозиториями GitHub и ключами OpenAI. У вас будет полнофункциональный бот GitHub через 10 минут. Нет необходимости настраивать веб-сервер, или веб-перехватчик для GitHub API, или сервер кеша/базы данных.

Как разветвить репозиторий шаблонов

Во-первых, разветвите этот репозиторий шаблонов с GitHub .

Файл src/lib.rsсодержит приложение бота (также известное как функция потока). Функция run()вызывается при запуске. Он прослушивает issue_commentи issuesсобытия из репозитория GitHub owner/repo. Эти события генерируются, когда в репозитории создается комментарий к новой задаче или новая задача.

#[no_mangle]
#[tokio::main(flavor = "current_thread")]
pub async fn run() {
    // Setup variables for
    //   ower: GitHub org to install the bot
    //   repo: GitHub repo to install the bot
    //   openai_key_name: Name for your OpenAI API key
    // All the values can be set in the source code or as env vars
    
    listen_to_event(&owner, &repo, vec!["issue_comment", "issues"], |payload| {
        handler(&owner, &repo, &openai_key_name, payload)
    })
    .await;
}

Функция handler()обрабатывает события, полученные listen_to_event(). Если событие является новым комментарием в задаче, бот вызывает API OpenAI ChatGPT, чтобы добавить текст комментария в существующую беседу, идентифицированную файлом issue.number. Он получает ответ от ChatGPT и добавляет комментарий в задачу.

Функция потока здесь автоматически и прозрачно управляет историей разговоров с API ChatGPT в локальном хранилище. Ключ API OpenAI также хранится в локальном хранилище, поэтому вместо помещения секретного текста в исходный код ключ можно идентифицировать по строковому имени в формате openai_key_name.

EventPayload::IssueCommentEvent(e) => {
    if e.comment.user.r#type != "Bot" {
        if let Some(b) = e.comment.body {
            if let Some(r) = chat_completion (
                    openai_key_name,
                    &format!("issue#{}", e.issue.number),
                    &b,
                    &ChatOptions::default(),
            ) {
                if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
                    write_error_log!(e.to_string());
                }
            }
        }
    }
}

Если событие представляет собой новую проблему, функция потока создает новый диалог, обозначенный значком issue.number, и запрашивает ответ от ChatGPT.

EventPayload::IssuesEvent(e) => {
    if e.action == IssuesEventAction::Closed {
        return;
    }

    let title = e.issue.title;
    let body = e.issue.body.unwrap_or("".to_string());
    let q = title + "\n" + &body;
    if let Some(r) = chat_completion (
            openai_key_name,
            &format!("issue#{}", e.issue.number),
            &q,
            &ChatOptions::default(),
    ) {
        if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
            write_error_log!(e.to_string());
        }
    }
}

Как развернуть функцию бессерверного потока

Как мы видим, код функции потока вызывает API SDK для выполнения сложных операций. Например,

  • Функция listen_to_event()регистрирует URL-адрес веб-перехватчика через API GitHub, чтобы handler()функция вызывалась при возникновении определенных событий в GitHub.
  • Функция chat_completion()вызывает API ChatGPT с именованным ключом API и прошлой историей/контекстом указанного разговора. Ключ API и история разговоров хранятся в кэше Redis.

Сервер веб-перехватчиков и кэш Redis являются внешними службами, от которых зависит SDK. Это означает, что функция потока должна работать в среде управляемого хоста, которая предоставляет такие внешние службы. Flows.network — это хост PaaS (платформа как услуга) для SDK функций потока.

Чтобы развернуть функцию потока в потоках. сеть, вам просто нужно импортировать ее исходный код в PaaS.

Сначала войдите в потоки. сеть из своей учетной записи GitHub. Импортируйте разветвленный репозиторий GitHub, содержащий исходный код функции потока, и выберите «С переменными среды».

Обратите внимание, что это НЕ репозиторий GitHub, где вы хотите развернуть бота. Это репозиторий для вашего исходного кода функции разветвленного потока.

CH1nUf8

Рисунок 2. Импортируйте репозиторий GitHub, который вы разветвили из шаблона функции потока, в потоки.network.

Установите переменные среды, чтобы указать функции потока на имя ключа OpenAI API ( open_ai_key) и репозиторий GitHub ( ownerи repo).

GitHub ownerи repoпеременные здесь указывают на репозиторий GitHub, где вы хотите развернуть бота, а НЕ на репозиторий исходного кода функции потока.

5gcTKMv

Рисунок 3. Задайте переменные среды для репозитория GitHub, где вы хотите развернуть бота, а также имя ключа API OpenAI.

Flows.network извлечет исходный код и встроит исходный код Rust в байт-код Wasm, используя стандартную cargoцепочку инструментов. Затем он запустит функцию потока Wasm в среде выполнения WasmEdge .

Как подключить функцию потока к GitHub и OpenAI

Хотя функция потока требует подключения к API OpenAI и GitHub, исходный код не имеет жестко запрограммированных ключей API, токенов доступа или логики OAUTH. Пакеты SDK для функций потоков позволяют разработчикам легко и безопасно взаимодействовать с внешними API-сервисами SaaS.

Flows.network обнаруживает, что функция потока требует подключения к API OpenAI и GitHub. Он представляет рабочие процессы пользовательского интерфейса для разработчиков:

  • Войдите в GitHub, разрешите доступ к событиям и зарегистрируйте функцию потока в качестве веб-перехватчика для получения этих событий.
  • Свяжите ключ API OpenAI с именем openai_key_name.

CpLDrub

Рис. 4. Внешние сервисы, требуемые функцией потока, подключены и горят зеленым цветом.

Как только внешние API-интерфейсы SaaS подключены и авторизованы, они становятся зелеными на панели функций потока. Теперь функция потока будет получать события, listen_to_event()для которых она предназначена. Он также получит прозрачный доступ к Redis для именованного ключа API OpenAI и кэшированного контекста разговора для поддержки chat_completion()функции SDK.

Что дальше

Бот GitHub — это лишь один из многих типов ботов, поддерживаемых потоками.network. Подключив функцию потока к каналу Slack, вы можете заставить ChatGPT участвовать в групповом обсуждении. Вот пример бота ChatGPT на основе Slack.

GitHub — потоки-сеть/совместный чат

фавиконпотоки-сетьGitHub

совместный чат

https://github.com/flows-network/collaborative-chatvoB27bjРисунок 5. Бот Slack ChatGPT.

Другой пример — ChatGPT отвечает на юридические вопросы в канале Slack. Функция потока добавляет подсказку к юридическому вопросу.

GitHub — потоки-сеть/робо-юрист

фавиконпотоки-сетьGitHub

робот-адвокат

https://github.com/flows-network/robo-lawyerafDM5imРисунок 6. Робот-юрист Slack.

Помимо GitHub и Slack, существует множество продуктов SaaS, которые вы можете интегрировать в потоки. сеть через их API.

Хотя примеры функций потока написаны на Rust, мы стремимся поддерживать SDK функций потока на основе JavaScript. Другими словами, функции платформы SDK, такие как listen_to_event()и chat_completion()будут иметь версию JavaScript. Функция потока JavaScript запускается внутри среды выполнения WasmEdge на платформеflow.network через модуль WasmEdge-QuickJS .

Источник: https://www.freecodecamp.org

#rust #chatbot #chatgpt

Как создать бессерверное приложение ChatGPT с помощью Rust
曾 俊

曾 俊

1679390160

Rust でサーバーレス ChatGPT アプリを作成する方法

Rust を使用してサーバーレス ChatGPT アプリを作成する方法を学びます。サーバーレス GitHub ボットを作成します。ボットは、Rust で記述されたサーバーレス関数です。ボットを使用すると、GitHub ユーザーは ChatGPT とチャットしたり、GitHub の問題でお互いにチャットしたりできます。 

2023 年 3 月にOpenAI がChatGPT の公式 API をリリースして以来、多くの開発者や起業家は、それを自社の事業運営に統合することに関心を持っています。

しかし、これを行うことを困難にするいくつかの重大な障壁が残っています。

  • OpenAI は、 ChatGPT 用の単純なステートレス APIを提供します。開発者は、アプリケーションによって管理されるキャッシュまたはデータベースで、各会話の履歴とコンテキストを追跡する必要があります。開発者は、API キーを管理および保護する必要もあります。アプリケーションのビジネス ロジックに関係のないボイラープレート コードが多数あります。
  • ChatGPT API アプリケーションの「自然な」UI は、スレッド化されたチャットです。しかし、従来の Web やアプリのフレームワークで「チャット UI」を作成するのは困難です。実際、最も一般的に使用されているチャット UI は、Slack、Discord、さらにはフォーラム (GitHub ディスカッションなど) などのメッセージング アプリに既に存在しています。ChatGPT API 応答を既存のメッセージング サービスに接続する簡単な方法が必要です。

この記事では、サーバーレス GitHub ボットを作成する方法を紹介します。ボットを使用すると、GitHub ユーザーは ChatGPT とチャットしたり、GitHub の問題でお互いにチャットしたりできます。質問するか、コメントを残して別の会話スレッドに参加することで試すことができます。つまり、このプロジェクトは GitHub Issues のスレッド化されたメッセージ UI を独自のチャット UI として使用します。

7eWhQ8I

図 1. ChatGPT を使用して Rust を学習する。https://github.com/second-state/chat-with-chatgpt/issues/31を参照してください

ボットは、Rust で記述されたサーバーレス関数です。サンプルをフォークし、フォークをflow.networkにデプロイし、独自の GitHub リポジトリおよび OpenAI キーと対話するように構成します。10 分で完全に機能する GitHub ボットが完成します。Web サーバーや GitHub API の Webhook、キャッシュ/データベース サーバーをセットアップする必要はありません。

テンプレートリポジトリをフォークする方法

まず、このテンプレート リポジトリを GitHub からフォークします

このsrc/lib.rsファイルには、ボット アプリケーション (フロー機能とも呼ばれます) が含まれています。このrun()関数は、起動時に呼び出されます。GitHub repo からイベントをissue_commentリッスンします。これらのイベントは、新しい問題のコメントまたは新しい問題がリポジトリに作成されたときに発行されます。issuesowner/repo

#[no_mangle]
#[tokio::main(flavor = "current_thread")]
pub async fn run() {
    // Setup variables for
    //   ower: GitHub org to install the bot
    //   repo: GitHub repo to install the bot
    //   openai_key_name: Name for your OpenAI API key
    // All the values can be set in the source code or as env vars
    
    listen_to_event(&owner, &repo, vec!["issue_comment", "issues"], |payload| {
        handler(&owner, &repo, &openai_key_name, payload)
    })
    .await;
}

The handler() function processes the events received by listen_to_event(). If the event is a new comment in an issue, the bot calls OpenAI's ChatGPT API to add the comment text into an existing conversation identified by the issue.number. It receives a response from ChatGPT, and adds a comment in the issue.

The flow function here automatically and transparently manages the conversation history with the ChatGPT API in a local storage. The OpenAI API key is also stored in the local storage so that instead of putting the secret text in the source code, the key can be identified by a string name in openai_key_name.

EventPayload::IssueCommentEvent(e) => {
    if e.comment.user.r#type != "Bot" {
        if let Some(b) = e.comment.body {
            if let Some(r) = chat_completion (
                    openai_key_name,
                    &format!("issue#{}", e.issue.number),
                    &b,
                    &ChatOptions::default(),
            ) {
                if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
                    write_error_log!(e.to_string());
                }
            }
        }
    }
}

If the event is a new issue, the flow function creates a new conversation identified by issue.number, and requests a response from ChatGPT.

EventPayload::IssuesEvent(e) => {
    if e.action == IssuesEventAction::Closed {
        return;
    }

    let title = e.issue.title;
    let body = e.issue.body.unwrap_or("".to_string());
    let q = title + "\n" + &body;
    if let Some(r) = chat_completion (
            openai_key_name,
            &format!("issue#{}", e.issue.number),
            &q,
            &ChatOptions::default(),
    ) {
        if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
            write_error_log!(e.to_string());
        }
    }
}

How to Deploy the Serverless Flow Function

As we can see, the flow function code calls SDK APIs to perform complex operations. For example,

  • The listen_to_event() function registers a webhook URL through GitHub API so that the handler() function will be called when certain events occur in GitHub.
  • The chat_completion() function calls the ChatGPT API with the named API key and past history / context of the specified conversation. The API key and conversation history are stored in a Redis cache.

The webhook server and the Redis cache are both external services the SDK depends on. That means the flow function must run inside a managed host environment that provides such external services. Flows.network is a PaaS (Platform as a Service) host for the flow function SDKs.

In order to deploy the flow function on flows.network, you simply need to import its source code to the PaaS.

First, sign into flows.network from your GitHub account. Import your forked GitHub repo that contains the flow function source code and choose "With Environment Variables".

Note that this is NOT the GitHub repo where you want to deploy the bot. This is the repo for your forked flow function source code.

CH1nUf8

Figure 2. Import the GitHub repo you forked from the flow function template into flows.network.

Set the environment variables to point the flow function to the OpenAI API key name (open_ai_key) and GitHub repo (owner and repo).

The GitHub owner and repo variables here point to the GitHub repo where you want to deploy the bot, NOT the repo for the flow function source code.

5gcTKMv

図 3. ボットをデプロイする GitHub リポジトリの環境変数と OpenAI API キー名を設定します。

Flows.network はソース コードを取得し、標準ツールチェーンを使用して Rust ソース コードを Wasm バイトコードにビルドしますcargo次に、 WasmEdge ランタイムで Wasm フロー関数を実行します。

Flow Function を GitHub と OpenAI に接続する方法

フロー関数には OpenAI および GitHub API への接続が必要ですが、ソース コードにはハードコードされた API キー、アクセス トークン、または OAUTH ロジックはありません。フロー関数 SDK により、開発者は外部の SaaS API サービスと簡単かつ安全にやり取りできるようになりました。

Flows.network は、フロー関数が OpenAI および GitHub API への接続を必要とすることを検出します。開発者が次のことを行うための UI ワークフローを示します。

  • GitHub にログインし、イベントへのアクセスを承認し、それらのイベントを受信するための webhook としてフロー関数を登録します。
  • OpenAI API キーを name に関連付けますopenai_key_name

CpLDrub

図 4. フロー機能に必要な外部サービスが接続され、緑色に変わります。

外部 SaaS API が接続されて承認されると、フロー機能ダッシュボードで緑色に変わります。これで、フロー関数が対象のイベントを受け取りますlisten_to_event()。また、SDK 機能をサポートするために、指定された OpenAI API キーとキャッシュされた会話コンテキストの Redis への透過的なアクセスも取得しますchat_completion()

次は何ですか

GitHub ボットは、flow.network がサポートできる多くのボット タイプの 1 つにすぎません。フロー機能を Slack チャンネルに接続することで、ChatGPT をグループ ディスカッションに参加させることができます。Slack ベースの ChatGPT ボットの例を次に示します。

GitHub - フロー ネットワーク/共同チャット

ファビコンフロー ネットワークGitHub

共同チャット

https://github.com/flows-network/collaborative-chatvoB27bj図 5. Slack ChatGPT ボット。

もう 1 つの例は、ChatGPT が Slack チャネルで法的な質問に回答することです。フロー関数は、法的な質問の前にプロンプ​​トを追加します。

GitHub - フロー ネットワーク/ロボ弁護士

ファビコンフロー ネットワークGitHub

ロボ弁護士

https://github.com/flows-network/robo-lawyerafDM5im図 6. Slack ロボ弁護士ボット。

GitHub と Slack 以外にも、API を介して flow.network に統合できる SaaS 製品が多数あります。

サンプルのフロー関数は Rust で記述されていますが、JavaScript ベースのフロー関数 SDK をサポートすることを目指しています。つまり、 や などのプラットフォーム SDK 関数には、listen_to_event()JavaScriptchat_completion()バージョンがあります。JavaScript フロー関数は、WasmEdge-QuickJSモジュールを介して、flows.network プラットフォームのWasmEdge ランタイム内で実行されます。

ソース: https://www.freecodecamp.org

#rust #chatbot #chatgpt

Rust でサーバーレス ChatGPT アプリを作成する方法
Adam Daniels

Adam Daniels

1679386521

Comment créer une application ChatGPT sans serveur avec Rust

Découvrez comment créer une application ChatGPT sans serveur avec Rust. Créez un bot GitHub sans serveur. Le bot est une fonction sans serveur écrite en Rust. Le bot permet aux utilisateurs de GitHub de discuter avec ChatGPT et entre eux dans les problèmes GitHub. 

Depuis qu'OpenAI a publié une API officielle pour ChatGPT en mars 2023, de nombreux développeurs et entrepreneurs souhaitent l'intégrer à leurs propres opérations commerciales.

Mais certains obstacles importants subsistent qui rendent difficile pour eux de le faire :

  • OpenAI fournit une API simple sans état pour ChatGPT. Le développeur doit garder une trace de l'historique et du contexte de chaque conversation dans un cache ou une base de données gérée par l'application. Le développeur doit également gérer et protéger les clés API. Il y a beaucoup de code passe-partout sans rapport avec la logique métier de l'application.
  • L'interface utilisateur « naturelle » de l'application API ChatGPT est un chat fileté. Mais il est difficile de créer une «interface utilisateur de chat» dans un cadre Web ou d'application traditionnel. En fait, l'interface utilisateur de chat la plus couramment utilisée existe déjà dans des applications de messagerie comme Slack, Discord et même des forums (par exemple, GitHub Discussions). Nous avons besoin d'un moyen simple de connecter les réponses de l'API ChatGPT à un service de messagerie existant.

Dans cet article, je vais vous montrer comment créer un bot GitHub sans serveur. Le bot permet aux utilisateurs de GitHub de discuter avec ChatGPT et entre eux dans les problèmes GitHub. Vous pouvez l'essayer en posant une question ou en rejoignant un autre fil de conversation en laissant un commentaire. En d'autres termes, ce projet utilise l'interface utilisateur des messages filetés de GitHub Issues comme sa propre interface utilisateur de chat.

7eWhQ8I

Figure 1. Apprendre Rust avec ChatGPT. voir https://github.com/second-state/chat-with-chatgpt/issues/31

Le bot est une fonction sans serveur écrite en Rust. Bifurquez simplement l'exemple, déployez votre fork sur flows.network et configurez-le pour interagir avec vos propres référentiels GitHub et clés OpenAI. Vous aurez un bot GitHub entièrement fonctionnel en 10 minutes. Il n'est pas nécessaire de configurer un serveur Web, ou un webhook pour l'API GitHub, ou un serveur de cache/base de données.

Comment forker le référentiel de modèles

Tout d'abord, bifurquez ce dépôt de modèle à partir de GitHub .

Le src/lib.rsfichier contient l'application bot (également connue sous le nom de fonction de flux). La run()fonction est appelée au démarrage. Il écoute issue_commentles issuesévénements du dépôt GitHub owner/repo. Ces événements sont émis lorsqu'un nouveau commentaire de problème ou un nouveau problème est créé dans le référentiel.

#[no_mangle]
#[tokio::main(flavor = "current_thread")]
pub async fn run() {
    // Setup variables for
    //   ower: GitHub org to install the bot
    //   repo: GitHub repo to install the bot
    //   openai_key_name: Name for your OpenAI API key
    // All the values can be set in the source code or as env vars
    
    listen_to_event(&owner, &repo, vec!["issue_comment", "issues"], |payload| {
        handler(&owner, &repo, &openai_key_name, payload)
    })
    .await;
}

La handler()fonction traite les événements reçus par listen_to_event(). Si l'événement est un nouveau commentaire dans un ticket, le bot appelle l'API ChatGPT d'OpenAI pour ajouter le texte du commentaire dans une conversation existante identifiée par le issue.number. Il reçoit une réponse de ChatGPT et ajoute un commentaire dans le problème.

La fonction de flux gère ici automatiquement et de manière transparente l'historique des conversations avec l'API ChatGPT dans un stockage local. La clé API OpenAI est également stockée dans le stockage local afin qu'au lieu de mettre le texte secret dans le code source, la clé puisse être identifiée par un nom de chaîne dans openai_key_name.

EventPayload::IssueCommentEvent(e) => {
    if e.comment.user.r#type != "Bot" {
        if let Some(b) = e.comment.body {
            if let Some(r) = chat_completion (
                    openai_key_name,
                    &format!("issue#{}", e.issue.number),
                    &b,
                    &ChatOptions::default(),
            ) {
                if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
                    write_error_log!(e.to_string());
                }
            }
        }
    }
}

Si l'événement est un nouveau problème, la fonction de flux crée une nouvelle conversation identifiée par issue.numberet demande une réponse à ChatGPT.

EventPayload::IssuesEvent(e) => {
    if e.action == IssuesEventAction::Closed {
        return;
    }

    let title = e.issue.title;
    let body = e.issue.body.unwrap_or("".to_string());
    let q = title + "\n" + &body;
    if let Some(r) = chat_completion (
            openai_key_name,
            &format!("issue#{}", e.issue.number),
            &q,
            &ChatOptions::default(),
    ) {
        if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
            write_error_log!(e.to_string());
        }
    }
}

Comment déployer la fonction de flux sans serveur

Comme nous pouvons le voir, le code de la fonction de flux appelle les API SDK pour effectuer des opérations complexes. Par exemple,

  • La listen_to_event()fonction enregistre une URL de webhook via l'API GitHub afin que la handler()fonction soit appelée lorsque certains événements se produisent dans GitHub.
  • La chat_completion()fonction appelle l'API ChatGPT avec la clé API nommée et l'historique/contexte passé de la conversation spécifiée. La clé API et l'historique des conversations sont stockés dans un cache Redis.

Le serveur webhook et le cache Redis sont tous deux des services externes dont dépend le SDK. Cela signifie que la fonction de flux doit s'exécuter dans un environnement hôte géré qui fournit de tels services externes. Flows.network est un hôte PaaS (Platform as a Service) pour les SDK de la fonction de flux.

Pour déployer la fonction flow sur flows.network, il vous suffit d'importer son code source dans le PaaS.

Tout d'abord, connectez-vous à flows.network depuis votre compte GitHub. Importez votre référentiel GitHub forké qui contient le code source de la fonction de flux et choisissez "Avec des variables d'environnement".

Notez qu'il ne s'agit PAS du référentiel GitHub sur lequel vous souhaitez déployer le bot. Il s'agit du référentiel pour le code source de votre fonction de flux forké.

CH1nUf8

Figure 2. Importez le référentiel GitHub que vous avez créé à partir du modèle de fonction de flux dans flows.network.

Définissez les variables d'environnement pour faire pointer la fonction de flux vers le nom de la clé d'API OpenAI ( open_ai_key) et le référentiel GitHub ( owneret repo).

Le GitHub owneret repoles variables ici pointent vers le référentiel GitHub où vous souhaitez déployer le bot, PAS le référentiel pour le code source de la fonction de flux.

5gcTKMv

Figure 3. Définissez les variables d'environnement pour le référentiel GitHub où vous souhaitez déployer le bot, ainsi que le nom de la clé d'API OpenAI.

Flows.network récupérera le code source et construira le code source Rust dans le bytecode Wasm à l'aide de la chaîne cargod'outils standard. Il exécutera ensuite la fonction de flux Wasm dans WasmEdge Runtime .

Comment connecter la fonction Flow à GitHub et OpenAI

Alors que la fonction de flux nécessite des connexions aux API OpenAI et GitHub, le code source n'a pas de clés d'API codées en dur, de jetons d'accès ou de logique OAUTH. Les SDK de la fonction de flux ont permis aux développeurs d'interagir facilement et en toute sécurité avec les services d'API SaaS externes.

Flows.network découvre que la fonction de flux nécessite des connexions aux API OpenAI et GitHub. Il présente des flux de travail d'interface utilisateur permettant aux développeurs de :

  • Connectez-vous à GitHub, autorisez l'accès aux événements et enregistrez la fonction de flux en tant que webhook pour recevoir ces événements.
  • Associez une clé API OpenAI au nom openai_key_name.

CpLDrub

Figure 4. Les services externes requis par la fonction de flux sont connectés et deviennent verts.

Une fois les API SaaS externes connectées et autorisées, elles deviennent vertes sur le tableau de bord de la fonction de flux. La fonction de flux recevra désormais les événements listen_to_event()pour lesquels elle est. Il obtiendra également un accès transparent à Redis pour la clé d'API OpenAI nommée et le contexte de conversation mis en cache pour prendre en charge la chat_completion()fonction SDK.

Et après

Le bot GitHub n'est qu'un des nombreux types de bot pris en charge par flows.network. En connectant la fonction de flux à un canal Slack, vous pouvez faire participer ChatGPT à votre discussion de groupe. Voici un exemple de bot ChatGPT basé sur Slack.

GitHub - flux-réseau/collaboratif-chat

faviconflux-réseauGitHub

chat collaboratif

https://github.com/flows-network/collaborative-chatvoB27bjFigure 5. Le bot Slack ChatGPT.

Un autre exemple est que ChatGPT réponde à des questions juridiques dans un canal Slack. La fonction de flux fait précéder la question juridique d'une invite.

GitHub - réseau de flux/avocat-robot

faviconflux-réseauGitHub

robot-avocat

https://github.com/flows-network/robo-lawyerafDM5imFigure 6. Le robot robo avocat Slack.

Outre GitHub et Slack, il existe de nombreux produits SaaS que vous pouvez intégrer à flows.network via leurs API.

Bien que les exemples de fonctions de flux soient écrits en Rust, nous visons à prendre en charge les SDK de fonctions de flux basés sur JavaScript. En d'autres termes, les fonctions SDK de la plate-forme telles que listen_to_event()et chat_completion()auront une version JavaScript. La fonction de flux JavaScript s'exécute dans le runtime WasmEdge sur la plate-forme flows.network via le module WasmEdge-QuickJS .

Source : https://www.freecodecamp.org

#rust #chatbot #chatgpt

Comment créer une application ChatGPT sans serveur avec Rust

Cómo crear una aplicación ChatGPT sin servidor con Rust

Aprenda a crear una aplicación ChatGPT sin servidor con Rust. Cree un bot de GitHub sin servidor. El bot es una función sin servidor escrita en Rust. El bot permite a los usuarios de GitHub chatear con ChatGPT y entre ellos en Problemas de GitHub. 

Desde que OpenAI lanzó una API oficial para ChatGPT en marzo de 2023, muchos desarrolladores y empresarios están interesados ​​en integrarla en sus propias operaciones comerciales.

Pero quedan algunas barreras importantes que les dificultan hacer esto:

  • OpenAI proporciona una API sin estado simple para ChatGPT. El desarrollador debe realizar un seguimiento del historial y el contexto de cada conversación en una caché o base de datos administrada por la aplicación. El desarrollador también necesita administrar y salvaguardar las claves API. Hay mucho código repetitivo que no está relacionado con la lógica empresarial de la aplicación.
  • La interfaz de usuario "natural" para la aplicación API de ChatGPT es un chat encadenado. Pero es difícil crear una "interfaz de usuario de chat" en un marco de aplicación o web tradicional. De hecho, la interfaz de usuario de chat más utilizada ya existe en aplicaciones de mensajería como Slack, Discord e incluso foros (por ejemplo, discusiones de GitHub). Necesitamos una forma sencilla de conectar las respuestas de la API de ChatGPT a un servicio de mensajería existente.

En este artículo, le mostraré cómo crear un bot de GitHub sin servidor. El bot permite a los usuarios de GitHub chatear con ChatGPT y entre ellos en Problemas de GitHub. Puedes probarlo haciendo una pregunta o uniéndote a otro hilo de conversación dejando un comentario. En otras palabras, este proyecto usa la IU de mensajes encadenados de GitHub Issues como su propia IU de chat.

7eWhQ8I

Figura 1. Aprendiendo Rust con ChatGPT. consulte https://github.com/second-state/chat-with-chatgpt/issues/31

El bot es una función sin servidor escrita en Rust. Simplemente bifurque el ejemplo, implemente su bifurcación enflows.network y configúrelo para interactuar con sus propios repositorios de GitHub y claves de OpenAI. Tendrás un bot de GitHub completamente funcional en 10 minutos. No es necesario configurar un servidor web, un webhook para la API de GitHub o un servidor de caché/base de datos.

Cómo bifurcar el repositorio de plantillas

Primero, bifurque este repositorio de plantillas de GitHub .

El src/lib.rsarchivo contiene la aplicación de bot (también conocida como la función de flujo). La run()función se llama al iniciar. Escucha issue_commenteventos issuesdel repositorio de GitHub owner/repo. Esos eventos se emiten cuando se crea un nuevo comentario de problema o un nuevo problema en el repositorio.

#[no_mangle]
#[tokio::main(flavor = "current_thread")]
pub async fn run() {
    // Setup variables for
    //   ower: GitHub org to install the bot
    //   repo: GitHub repo to install the bot
    //   openai_key_name: Name for your OpenAI API key
    // All the values can be set in the source code or as env vars
    
    listen_to_event(&owner, &repo, vec!["issue_comment", "issues"], |payload| {
        handler(&owner, &repo, &openai_key_name, payload)
    })
    .await;
}

The handler() function processes the events received by listen_to_event(). If the event is a new comment in an issue, the bot calls OpenAI's ChatGPT API to add the comment text into an existing conversation identified by the issue.number. It receives a response from ChatGPT, and adds a comment in the issue.

The flow function here automatically and transparently manages the conversation history with the ChatGPT API in a local storage. The OpenAI API key is also stored in the local storage so that instead of putting the secret text in the source code, the key can be identified by a string name in openai_key_name.

EventPayload::IssueCommentEvent(e) => {
    if e.comment.user.r#type != "Bot" {
        if let Some(b) = e.comment.body {
            if let Some(r) = chat_completion (
                    openai_key_name,
                    &format!("issue#{}", e.issue.number),
                    &b,
                    &ChatOptions::default(),
            ) {
                if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
                    write_error_log!(e.to_string());
                }
            }
        }
    }
}

If the event is a new issue, the flow function creates a new conversation identified by issue.number, and requests a response from ChatGPT.

EventPayload::IssuesEvent(e) => {
    if e.action == IssuesEventAction::Closed {
        return;
    }

    let title = e.issue.title;
    let body = e.issue.body.unwrap_or("".to_string());
    let q = title + "\n" + &body;
    if let Some(r) = chat_completion (
            openai_key_name,
            &format!("issue#{}", e.issue.number),
            &q,
            &ChatOptions::default(),
    ) {
        if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
            write_error_log!(e.to_string());
        }
    }
}

How to Deploy the Serverless Flow Function

As we can see, the flow function code calls SDK APIs to perform complex operations. For example,

  • The listen_to_event() function registers a webhook URL through GitHub API so that the handler() function will be called when certain events occur in GitHub.
  • The chat_completion() function calls the ChatGPT API with the named API key and past history / context of the specified conversation. The API key and conversation history are stored in a Redis cache.

The webhook server and the Redis cache are both external services the SDK depends on. That means the flow function must run inside a managed host environment that provides such external services. Flows.network is a PaaS (Platform as a Service) host for the flow function SDKs.

Para implementar la función de flujo enflows.network, simplemente necesita importar su código fuente a la PaaS.

Primero, inicie sesión enflows.network desde su cuenta de GitHub. Importe su repositorio de GitHub bifurcado que contiene el código fuente de la función de flujo y elija "Con variables de entorno".

Tenga en cuenta que este NO es el repositorio de GitHub donde desea implementar el bot. Este es el repositorio para el código fuente de la función de flujo bifurcado.

CH1nUf8

Figura 2. Importe el repositorio de GitHub que bifurcó de la plantilla de la función de flujo aflows.network.

Establezca las variables de entorno para apuntar la función de flujo al nombre de clave de la API de OpenAI ( open_ai_key) y al repositorio de GitHub ( ownery repo).

El GitHub ownery repolas variables aquí apuntan al repositorio de GitHub donde desea implementar el bot, NO al repositorio para el código fuente de la función de flujo.

5gcTKMv

Figura 3. Establezca las variables de entorno para el repositorio de GitHub donde desea implementar el bot, así como el nombre de la clave de la API de OpenAI.

Flows.network buscará el código fuente y construirá el código fuente de Rust en el código de bytes de Wasm utilizando la cargocadena de herramientas estándar. A continuación, ejecutará la función de flujo de Wasm en WasmEdge Runtime .

Cómo conectar la función de flujo a GitHub y OpenAI

Si bien la función de flujo requiere conexiones a las API de OpenAI y GitHub, el código fuente no tiene claves API codificadas, tokens de acceso ni lógica OAUTH. Los SDK de la función de flujos han hecho que sea fácil y seguro para los desarrolladores interactuar con los servicios API de SaaS externos.

Flows.network descubre que la función de flujo requiere conexiones a las API de OpenAI y GitHub. Presenta flujos de trabajo de interfaz de usuario para que los desarrolladores:

  • Inicie sesión en GitHub, autorice el acceso a los eventos y registre la función de flujo como webhook para recibir esos eventos.
  • Asocia una clave API de OpenAI con el nombre openai_key_name.

CpLDrub

Figura 4. Los servicios externos requeridos por la función de flujo están conectados y se vuelven verdes.

Una vez que las API de SaaS externas están conectadas y autorizadas, se vuelven verdes en el panel de funciones de flujo. La función de flujo ahora recibirá los eventos para los que la listen_to_event()necesita. También obtendrá acceso transparente a Redis para la clave API de OpenAI nombrada y el contexto de conversación en caché para admitir la chat_completion()función SDK.

Que sigue

El bot de GitHub es solo uno de los muchos tipos de bot que flow.network puede admitir. Al conectar la función de flujo a un canal de Slack, puede hacer que ChatGPT participe en su discusión grupal. Este es un ejemplo de un bot ChatGPT basado en Slack.

GitHub - red de flujos/chat colaborativo

faviconflujos-networkGitHub

chat colaborativo

https://github.com/flows-network/collaborative-chatvoB27bjFigura 5. El bot Slack ChatGPT.

Otro ejemplo es que ChatGPT responda preguntas legales en un canal de Slack. La función de flujo antepone la pregunta legal con un aviso.

GitHub - red de flujos/robo-abogado

faviconflujos-networkGitHub

robo-abogado

https://github.com/flows-network/robo-lawyerafDM5imFigura 6. El robot abogado robo de Slack.

Además de GitHub y Slack, hay muchos productos SaaS que puede integrar enflows.network a través de sus API.

Si bien las funciones de flujo de ejemplo están escritas en Rust, nuestro objetivo es admitir SDK de funciones de flujo basadas en JavaScript. En otras palabras, las funciones SDK de la plataforma como listen_to_event()y chat_completion()tendrán una versión de JavaScript. La función de flujo de JavaScript se ejecuta dentro de WasmEdge Runtime en la plataforma de flujos.network a través del módulo WasmEdge-QuickJS .

Fuente: https://www.freecodecamp.org

#rust #chatbot #chatgpt

Cómo crear una aplicación ChatGPT sin servidor con Rust

วิธีสร้างแอป ChatGPT แบบไร้เซิร์ฟเวอร์ด้วย Rust

เรียนรู้วิธีสร้างแอป ChatGPT แบบไร้เซิร์ฟเวอร์ด้วย Rust สร้างบอต GitHub แบบไร้เซิร์ฟเวอร์ บอทเป็นฟังก์ชันไร้เซิร์ฟเวอร์ที่เขียนด้วยภาษาสนิม บอทช่วยให้ผู้ใช้ GitHub แชทกับ ChatGPT และแชทกันใน GitHub Issues 

ตั้งแต่ OpenAI เปิดตัว API อย่างเป็นทางการสำหรับ ChatGPTในเดือนมีนาคม 2023 นักพัฒนาและผู้ประกอบการจำนวนมากสนใจที่จะรวมเข้ากับการดำเนินธุรกิจของตนเอง

แต่ยังมีอุปสรรคสำคัญบางประการที่ทำให้พวกเขาทำสิ่งนี้ได้ยาก:

  • OpenAI จัดเตรียมAPI ไร้สถานะอย่างง่ายสำหรับ ChatGPT นักพัฒนาจำเป็นต้องติดตามประวัติและบริบทของการสนทนาแต่ละครั้งในแคชหรือฐานข้อมูลที่จัดการโดยแอปพลิเคชัน นักพัฒนายังต้องจัดการและปกป้องคีย์ API มีรหัสสำเร็จรูปจำนวนมากที่ไม่เกี่ยวข้องกับตรรกะทางธุรกิจของแอปพลิเคชัน
  • UI "ธรรมชาติ" สำหรับแอปพลิเคชัน ChatGPT API คือการแชทแบบเธรด แต่การสร้าง “แชท UI” ในเฟรมเวิร์กเว็บหรือแอปแบบดั้งเดิมนั้นทำได้ยาก ที่จริงแล้ว UI แชทที่ใช้บ่อยที่สุดมีอยู่แล้วในแอพส่งข้อความ เช่น Slack, Discord และแม้แต่ฟอรัม (เช่น GitHub Discussions) เราต้องการวิธีง่ายๆ ในการเชื่อมต่อ ChatGPT API กับบริการส่งข้อความที่มีอยู่

ในบทความนี้ ฉันจะแสดงวิธีสร้างบอท GitHub แบบไร้เซิร์ฟเวอร์ บอทช่วยให้ผู้ใช้ GitHub แชทกับ ChatGPT และแชทกันใน GitHub Issues คุณสามารถลองได้โดยถามคำถามหรือเข้าร่วมเธรดการสนทนาอื่นโดยแสดงความคิดเห็น กล่าวอีกนัยหนึ่ง โปรเจ็กต์นี้ใช้ UI ข้อความแบบเธรดของ GitHub Issues เป็น UI แชทของตัวเอง

7eWhQ8I

รูปที่ 1 การเรียนรู้สนิมด้วย ChatGPT ดูhttps://github.com/second-state/chat-with-chatgpt/issues/31

บอทเป็นฟังก์ชันไร้เซิร์ฟเวอร์ที่เขียนด้วยภาษาสนิม เพียงแค่แยกตัวอย่าง ปรับใช้ส้อมของคุณบนFlow.networkและกำหนดค่าให้โต้ตอบกับที่เก็บ GitHub และคีย์ OpenAI ของคุณเอง คุณจะมีบอท GitHub ที่ทำงานได้อย่างสมบูรณ์ใน 10 นาที ไม่จำเป็นต้องตั้งค่าเว็บเซิร์ฟเวอร์หรือเว็บฮุคสำหรับ GitHub API หรือเซิร์ฟเวอร์แคช / ฐานข้อมูล

วิธี Fork เทมเพลต Repo

ขั้นแรกให้แยก repo เทมเพลตนี้ออกจาก GitHub

ไฟล์ นี้src/lib.rsมีแอปพลิเคชันบอท (หรือที่เรียกว่าฟังก์ชันโฟลว์) ฟังก์ชัน นี้run()ถูกเรียกใช้เมื่อเริ่มต้น มันฟังissue_commentและกิจกรรมissuesจาก GitHub repo owner/repoเหตุการณ์เหล่านั้นจะถูกปล่อยออกมาเมื่อมีการสร้างข้อคิดเห็นเกี่ยวกับปัญหาใหม่หรือปัญหาใหม่ในที่เก็บ

#[no_mangle]
#[tokio::main(flavor = "current_thread")]
pub async fn run() {
    // Setup variables for
    //   ower: GitHub org to install the bot
    //   repo: GitHub repo to install the bot
    //   openai_key_name: Name for your OpenAI API key
    // All the values can be set in the source code or as env vars
    
    listen_to_event(&owner, &repo, vec!["issue_comment", "issues"], |payload| {
        handler(&owner, &repo, &openai_key_name, payload)
    })
    .await;
}

ฟังก์ชันhandler()ประมวลผลเหตุการณ์ที่ได้รับlisten_to_event()โดย หากเหตุการณ์นั้นเป็นความคิดเห็นใหม่ในปัญหา บอทจะเรียกใช้ ChatGPT API ของ OpenAI เพื่อเพิ่มข้อความความคิดเห็นลงในการสนทนาที่มีอยู่ซึ่งระบุโดยไฟล์issue.number. ได้รับการตอบกลับจาก ChatGPT และเพิ่มความคิดเห็นในปัญหา

ฟังก์ชันโฟลว์ที่นี่จัดการประวัติการสนทนาโดยอัตโนมัติและโปร่งใสด้วย ChatGPT API ในที่จัดเก็บในตัวเครื่อง คีย์ OpenAI API ยังถูกจัดเก็บไว้ในที่จัดเก็บในเครื่อง ดังนั้นแทนที่จะใส่ข้อความลับในซอร์สโค้ด คีย์สามารถระบุได้ด้วยชื่อสตริงในopenai_key_name.

EventPayload::IssueCommentEvent(e) => {
    if e.comment.user.r#type != "Bot" {
        if let Some(b) = e.comment.body {
            if let Some(r) = chat_completion (
                    openai_key_name,
                    &format!("issue#{}", e.issue.number),
                    &b,
                    &ChatOptions::default(),
            ) {
                if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
                    write_error_log!(e.to_string());
                }
            }
        }
    }
}

หากเหตุการณ์เป็นปัญหาใหม่ ฟังก์ชันโฟลว์จะสร้างการสนทนาใหม่ที่ระบุโดยissue.numberและร้องขอการตอบกลับจาก ChatGPT

EventPayload::IssuesEvent(e) => {
    if e.action == IssuesEventAction::Closed {
        return;
    }

    let title = e.issue.title;
    let body = e.issue.body.unwrap_or("".to_string());
    let q = title + "\n" + &body;
    if let Some(r) = chat_completion (
            openai_key_name,
            &format!("issue#{}", e.issue.number),
            &q,
            &ChatOptions::default(),
    ) {
        if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
            write_error_log!(e.to_string());
        }
    }
}

วิธีปรับใช้ฟังก์ชัน Serverless Flow

อย่างที่เราเห็น โค้ดฟังก์ชันโฟลว์เรียก API ของ SDK เพื่อดำเนินการที่ซับซ้อน ตัวอย่างเช่น,

  • ฟังก์ชันlisten_to_event()จะลงทะเบียน URL ของเว็บฮุคผ่าน GitHub API เพื่อให้handler()ฟังก์ชันนั้นถูกเรียกเมื่อมีเหตุการณ์บางอย่างเกิดขึ้นใน GitHub
  • ฟังก์ชันchat_completion()เรียก ChatGPT API ด้วยคีย์ API ที่มีชื่อและประวัติ/บริบทที่ผ่านมาของการสนทนาที่ระบุ คีย์ API และประวัติการสนทนาถูกจัดเก็บไว้ในแคช Redis

เซิร์ฟเวอร์เว็บฮุคและแคช Redis เป็นทั้งบริการภายนอกที่ SDK พึ่งพา ซึ่งหมายความว่าฟังก์ชันโฟลว์ต้องทำงานภายในสภาพแวดล้อมโฮสต์ที่มีการจัดการซึ่งให้บริการภายนอกดังกล่าว Flows.networkเป็นโฮสต์ PaaS (แพลตฟอร์มเป็นบริการ) สำหรับ SDK ของฟังก์ชันโฟลว์

ในการปรับใช้ฟังก์ชันโฟลว์บน Flow.network คุณเพียงต้องนำเข้าซอร์สโค้ดไปยัง PaaS

ขั้นแรก ลงชื่อเข้าใช้ Flow.network จากบัญชี GitHub ของคุณ นำเข้า repo GitHub ที่แยกของคุณซึ่งมีซอร์สโค้ดของฟังก์ชันโฟลว์และเลือก "ด้วยตัวแปรสภาพแวดล้อม"

โปรดทราบว่านี่ไม่ใช่ GitHub repo ที่คุณต้องการปรับใช้บอท นี่คือ repo สำหรับซอร์สโค้ดของฟังก์ชัน forked flow ของคุณ

CH1nUf8

รูปที่ 2 นำเข้า GitHub repo ที่คุณแยกจากเทมเพลตฟังก์ชันโฟลว์ไปยัง Flow.network

ตั้งค่าตัวแปรสภาพแวดล้อมให้ชี้ฟังก์ชันโฟลว์ไปที่ชื่อคีย์ OpenAI API ( open_ai_key) และ GitHub repo ( ownerและrepo)

GitHub ownerและrepoตัวแปรที่นี่ชี้ไปที่ GitHub repo ที่คุณต้องการปรับใช้บอท ไม่ใช่ repo สำหรับซอร์สโค้ดของฟังก์ชันโฟลว์

5gcTKMv

รูปที่ 3 ตั้งค่าตัวแปรสภาพแวดล้อมสำหรับ GitHub repo ที่คุณต้องการปรับใช้บอท รวมถึงชื่อคีย์ OpenAI API

Flows.network จะดึงซอร์สโค้ดและสร้างซอร์สโค้ด Rust เป็น Wasm bytecode โดยใช้cargotoolchain มาตรฐาน จากนั้นจะเรียกใช้ฟังก์ชัน Wasm flow ในWasmEdge Runtime

วิธีเชื่อมต่อ Flow Function กับ GitHub และ OpenAI

แม้ว่าฟังก์ชันโฟลว์ต้องการการเชื่อมต่อกับ OpenAI และ GitHub API แต่ซอร์สโค้ดไม่มีคีย์ API แบบฮาร์ดโค้ด โทเค็นการเข้าถึง หรือลอจิก OAUTH SDK ของฟังก์ชันโฟลว์ช่วยให้นักพัฒนาโต้ตอบกับบริการ SaaS API ภายนอกได้ง่ายและปลอดภัย

Flows.network ค้นพบว่าฟังก์ชันโฟลว์ต้องการการเชื่อมต่อกับ OpenAI และ GitHub API นำเสนอเวิร์กโฟลว์ UI สำหรับนักพัฒนาเพื่อ:

  • เข้าสู่ระบบ GitHub อนุญาตการเข้าถึงเหตุการณ์ และลงทะเบียนฟังก์ชันโฟลว์เป็นเว็บฮุคเพื่อรับเหตุการณ์เหล่านั้น
  • เชื่อมโยงคีย์ OpenAI API กับชื่อopenai_key_name.

CpLDrub

รูปที่ 4 บริการภายนอกที่จำเป็นสำหรับฟังก์ชันโฟลว์มีการเชื่อมต่อและเปลี่ยนเป็นสีเขียว

เมื่อเชื่อมต่อและอนุญาต SaaS API ภายนอกแล้ว จะเปลี่ยนเป็นสีเขียวบนแดชบอร์ดฟังก์ชันโฟลว์ ฟังก์ชันโฟลว์จะรับเหตุการณ์listen_to_event()สำหรับ นอกจากนี้ยังจะได้รับการเข้าถึง Redis อย่างโปร่งใสสำหรับคีย์ OpenAI API ที่มีชื่อและบริบทการสนทนาที่แคชไว้เพื่อรองรับchat_completion()ฟังก์ชัน SDK

อะไรต่อไป

บอท GitHub เป็นเพียงหนึ่งในประเภทบอทมากมายที่ Flow.network สามารถรองรับได้ เมื่อเชื่อมต่อฟังก์ชันโฟลว์เข้ากับแชนเนล Slack คุณจะได้รับ ChatGPT เพื่อเข้าร่วมการสนทนากลุ่มของคุณ นี่คือตัวอย่างของบอท ChatGPT ที่ใช้ Slack

GitHub - โฟลว์-เครือข่าย/การทำงานร่วมกัน-แชท

faviconกระแสเครือข่าย GitHub

ทำงานร่วมกันสนทนา

https://github.com/flows-network/collaborative-chatvoB27bjรูปที่ 5 บอท Slack ChatGPT

อีกตัวอย่างหนึ่งคือการให้ ChatGPT ตอบคำถามทางกฎหมายในช่อง Slack ฟังก์ชันโฟลว์เสริมคำถามทางกฎหมายด้วยข้อความแจ้ง

GitHub - เครือข่ายโฟลว์ / ทนายความหุ่นยนต์

faviconกระแสเครือข่าย GitHub

ทนายความหุ่นยนต์

https://github.com/flows-network/robo-lawyerafDM5imรูปที่ 6. บอทนักกฎหมาย robo ของ Slack

นอกจาก GitHub และ Slack แล้ว ยังมีผลิตภัณฑ์ SaaS มากมายที่คุณสามารถรวมเข้ากับ Flow.network ผ่าน API ของพวกเขาได้

แม้ว่าฟังก์ชันโฟลว์ตัวอย่างจะเขียนขึ้นใน Rust แต่เรามีเป้าหมายที่จะสนับสนุน SDK ของฟังก์ชันโฟลว์ที่ใช้ JavaScript กล่าวอีกนัยหนึ่ง ฟังก์ชัน SDK ของแพลตฟอร์ม เช่นlisten_to_event()และchat_completion()จะมีเวอร์ชัน JavaScript ฟังก์ชันโฟลว์ JavaScript ทำงานภายในWasmEdge Runtimeบนแพลตฟอร์ม Flow.network ผ่านโมดูลWasmEdge-QuickJS

ที่มา: https://www.freecodecamp.org

#rust #chatbot #chatgpt

วิธีสร้างแอป ChatGPT แบบไร้เซิร์ฟเวอร์ด้วย Rust
许 志强

许 志强

1679375640

如何使用 Rust 創建無服務器 ChatGPT 應用程序

了解如何使用 Rust 創建無服務器 ChatGPT 應用程序。創建無服務器 GitHub 機器人。該機器人是用 Rust 編寫的無服務器功能。該機器人允許 GitHub 用戶在 GitHub Issues 中與 ChatGPT 和彼此聊天。 

自 OpenAI在 2023 年 3 月發布了 ChatGPT 的官方 API以來,許多開發人員和企業家有興趣將其集成到自己的業務運營中。

但仍然存在一些重大障礙,使他們難以做到這一點:

  • OpenAI 為 ChatGPT 提供了一個簡單的無狀態 API。開發人員需要在應用程序管理的緩存或數據庫中跟踪每個對話的歷史和上下文。開發人員還需要管理和保護 API 密鑰。有很多與應用程序的業務邏輯無關的樣板代碼。
  • ChatGPT API 應用程序的“自然”用戶界面是線程聊天。但是很難在傳統的 Web 或應用程序框架中創建“聊天 UI”。事實上,最常用的聊天 UI 已經存在於 Slack、Discord 甚至論壇(例如 GitHub Discussions)等消息應用程序中。我們需要一種簡單的方法將 ChatGPT API 響應連接到現有的消息服務。

在本文中,我將向您展示如何創建無服務器 GitHub 機器人。該機器人允許 GitHub 用戶在 GitHub Issues 中與 ChatGPT 和彼此聊天。您可以通過提問來嘗試,或通過發表評論加入另一個對話線程。換句話說,這個項目使用 GitHub Issues 的線程消息 UI 作為它自己的聊天 UI。

7eWhQ8I

圖 1. 使用 ChatGPT 學習 Rust。請參閱https://github.com/second-state/chat-with-chatgpt/issues/31

The bot is a serverless function written in Rust. Just fork the example, deploy your fork on flows.network, and configure it to interact with your own GitHub repos and OpenAI keys. You will have a fully functional GitHub bot in 10 minutes. There is no need to set up a web server, or a webhook for GitHub API, or a cache / database server.

How to Fork the Template Repo

First, fork this template repo from GitHub.

The src/lib.rs file contains the bot application (also known as the flow function). The run() function is called upon starting up. It listens for issue_comment and issues events from the GitHub repo owner/repo. Those events are emitted when a new issue comment or a new issue is created in the repo.

#[no_mangle]
#[tokio::main(flavor = "current_thread")]
pub async fn run() {
    // Setup variables for
    //   ower: GitHub org to install the bot
    //   repo: GitHub repo to install the bot
    //   openai_key_name: Name for your OpenAI API key
    // All the values can be set in the source code or as env vars
    
    listen_to_event(&owner, &repo, vec!["issue_comment", "issues"], |payload| {
        handler(&owner, &repo, &openai_key_name, payload)
    })
    .await;
}

handler()函數處理 接收到的事件listen_to_event()。如果事件是問題中的新評論,則機器人會調用 OpenAI 的 ChatGPT API 以將評論文本添加到由issue.number. 它收到來自 ChatGPT 的響應,並在問題中添加評論。

此處的流功能自動透明地管理本地存儲中與 ChatGPT API 的對話歷史記錄。OpenAI API 密鑰也存儲在本地存儲中,因此無需將密文放在源代碼中,密鑰可以通過openai_key_name.

EventPayload::IssueCommentEvent(e) => {
    if e.comment.user.r#type != "Bot" {
        if let Some(b) = e.comment.body {
            if let Some(r) = chat_completion (
                    openai_key_name,
                    &format!("issue#{}", e.issue.number),
                    &b,
                    &ChatOptions::default(),
            ) {
                if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
                    write_error_log!(e.to_string());
                }
            }
        }
    }
}

如果該事件是一個新問題,流函數將創建一個由 標識的新對話issue.number,並請求 ChatGPT 的響應。

EventPayload::IssuesEvent(e) => {
    if e.action == IssuesEventAction::Closed {
        return;
    }

    let title = e.issue.title;
    let body = e.issue.body.unwrap_or("".to_string());
    let q = title + "\n" + &body;
    if let Some(r) = chat_completion (
            openai_key_name,
            &format!("issue#{}", e.issue.number),
            &q,
            &ChatOptions::default(),
    ) {
        if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
            write_error_log!(e.to_string());
        }
    }
}

Serverless Flow功能如何部署

我們可以看到,流程功能代碼調用SDK API來執行複雜的操作。例如,

  • listen_to_event()函數通過 GitHub API 註冊一個 webhook URL,以便handler()在 GitHub 中發生某些事件時調用該函數。
  • chat_completion()函數使用指定對話的指定 API 密鑰和過去的歷史/上下文調用 ChatGPT API。API 密鑰和對話歷史記錄存儲在 Redis 緩存中。

Webhook服務器和Redis緩存都是SDK依賴的外部服務。這意味著流功能必須在提供此類外部服務的託管主機環境中運行。Flows.network是流功能 SDK 的 PaaS(平台即服務)主機。

為了在 flows.network 上部署流功能,您只需將其源代碼導入 PaaS。

首先,從您的 GitHub 帳戶登錄 flows.network。導入包含流函數源代碼的分叉 GitHub 存儲庫並選擇“使用環境變量”。

請注意,這不是您要部署機器人的 GitHub 存儲庫。這是您的分叉流函數源代碼的存儲庫。

CH1nUf8

圖 2. 將您從流函數模板派生的 GitHub 存儲庫導入 flows.network。

設置環境變量以將流函數指向 OpenAI API 密鑰名稱 ( open_ai_key) 和 GitHub 存儲庫 (ownerrepo)。

此處的GitHubownerrepo變量指向您要部署機器人的 GitHub 存儲庫,而不是流函數源代碼的存儲庫。

5gcTKMv

圖 3. 為要部署機器人的 GitHub 存儲庫設置環境變量,以及 OpenAI API 密鑰名稱。

Flows.network 將獲取源代碼並使用標準cargo工具鏈將 Rust 源代碼構建為 Wasm 字節碼。然後它將在WasmEdge Runtime中運行 Wasm 流功能。

如何將流功能連接到 GitHub 和 OpenAI

雖然流函數需要連接到 OpenAI 和 GitHub API,但源代碼沒有硬編碼的 API 密鑰、訪問令牌或 OAUTH 邏輯。流功能 SDK 使開發人員可以輕鬆、安全地與外部 SaaS API 服務進行交互。

Flows.network 發現流函數需要連接到 OpenAI 和 GitHub API。它為開發人員提供了 UI 工作流,以便:

  • 登錄 GitHub,授權訪問事件,並將流函數註冊為 webhook 以接收這些事件。
  • 將 OpenAI API 密鑰與名稱相關聯openai_key_name

CpLDrub

圖 4. 流功能所需的外部服務已連接並變綠。

連接並授權外部 SaaS API 後,它們會在流功能儀表板上變為綠色。流程功能現在將接收它所針對的事件listen_to_event()。它還將透明訪問 Redis 以獲取指定的 OpenAI API 密鑰和緩存的對話上下文以支持chat_completion()SDK 功能。

下一步是什麼

GitHub 機器人只是 flows.network 可以支持的眾多機器人類型之一。通過將流功能連接到 Slack 頻道,您可以獲得 ChatGPT 來參與您的小組討論。下面是一個基於 Slack 的 ChatGPT 機器人的示例。

GitHub - 流網絡/協作聊天

圖標流網絡GitHub

協作聊天

https://github.com/flows-network/collaborative-chatvoB27bj圖 5.Slack ChatGPT 機器人。

另一個例子是讓 ChatGPT 在 Slack 頻道中回答法律問題。流程功能在法律問題前加上提示。

GitHub - flows-network/機器人律師

圖標流網絡GitHub

機器人律師

https://github.com/flows-network/robo-lawyerAFDM5IM圖 6.Slack 機器人律師機器人。

除了 GitHub 和 Slack,還有許多 SaaS 產品可以通過它們的 API 集成到 flows.network 中。

雖然示例流函數是用 Rust 編寫的,但我們的目標是支持基於 JavaScript 的流函數 SDK。也就是說,平台SDK等功能listen_to_event()都會chat_completion()有JavaScript版本。JavaScript 流功能通過WasmEdge-QuickJS模塊在 flows.network 平台上的WasmEdge Runtime內部運行。

資料來源: https: //www.freecodecamp.org

#rust #chatbot #chatgpt

如何使用 Rust 創建無服務器 ChatGPT 應用程序
Romolo  Morelli

Romolo Morelli

1679371980

Come creare un'app ChatGPT senza server con Rust

Scopri come creare un'app Serverless ChatGPT con Rust. Crea un bot GitHub senza server. Il bot è una funzione serverless scritta in Rust. Il bot consente agli utenti di GitHub di chattare con ChatGPT e tra loro in GitHub Issues. 

Da quando OpenAI ha rilasciato un'API ufficiale per ChatGPT nel marzo 2023, molti sviluppatori e imprenditori sono interessati a integrarla nelle proprie operazioni aziendali.

Ma rimangono alcuni ostacoli significativi che rendono difficile per loro farlo:

  • OpenAI fornisce una semplice API stateless per ChatGPT. Lo sviluppatore deve tenere traccia della cronologia e del contesto di ogni conversazione in una cache o in un database gestito dall'applicazione. Lo sviluppatore deve anche gestire e salvaguardare le chiavi API. C'è molto codice boilerplate non correlato alla logica aziendale dell'applicazione.
  • L'interfaccia utente "naturale" per l'applicazione API ChatGPT è una chat con thread. Ma è difficile creare una "chat UI" in un framework web o app tradizionale. In effetti, l'interfaccia utente della chat più comunemente utilizzata esiste già nelle app di messaggistica come Slack, Discord e persino nei forum (ad esempio, GitHub Discussions). Abbiamo bisogno di un modo semplice per connettere le risposte dell'API ChatGPT a un servizio di messaggistica esistente.

In questo articolo, ti mostrerò come creare un bot GitHub senza server. Il bot consente agli utenti di GitHub di chattare con ChatGPT e tra loro in GitHub Issues. Puoi provarlo ponendo una domanda o unendoti a un altro thread di conversazione lasciando un commento. In altre parole, questo progetto utilizza l'interfaccia utente dei messaggi in thread di GitHub Issues come propria interfaccia utente della chat.

7eWhQ8I

Figura 1. Apprendimento di Rust con ChatGPT. vedi https://github.com/second-state/chat-with-chatgpt/issues/31

Il bot è una funzione serverless scritta in Rust. Basta eseguire il fork dell'esempio, distribuire il fork suflows.network e configurarlo per interagire con i propri repository GitHub e le chiavi OpenAI. Avrai un bot GitHub completamente funzionante in 10 minuti. Non è necessario configurare un server Web o un webhook per l'API GitHub o un server cache/database.

Come eseguire il fork del repository di modelli

Per prima cosa, esegui il fork di questo repository di modelli da GitHub .

Il src/lib.rsfile contiene l'applicazione bot (nota anche come funzione di flusso). La run()funzione viene richiamata all'avvio. Ascolta issue_commented issueseventi dal repository GitHub owner/repo. Questi eventi vengono emessi quando nel repository viene creato un nuovo commento al problema o un nuovo problema.

#[no_mangle]
#[tokio::main(flavor = "current_thread")]
pub async fn run() {
    // Setup variables for
    //   ower: GitHub org to install the bot
    //   repo: GitHub repo to install the bot
    //   openai_key_name: Name for your OpenAI API key
    // All the values can be set in the source code or as env vars
    
    listen_to_event(&owner, &repo, vec!["issue_comment", "issues"], |payload| {
        handler(&owner, &repo, &openai_key_name, payload)
    })
    .await;
}

La handler()funzione elabora gli eventi ricevuti da listen_to_event(). Se l'evento è un nuovo commento in un problema, il bot chiama l'API ChatGPT di OpenAI per aggiungere il testo del commento in una conversazione esistente identificata dall'estensione issue.number. Riceve una risposta da ChatGPT e aggiunge un commento nel problema.

La funzione di flusso qui gestisce automaticamente e in modo trasparente la cronologia delle conversazioni con l'API ChatGPT in un archivio locale. La chiave API OpenAI è anche memorizzata nella memoria locale in modo che invece di inserire il testo segreto nel codice sorgente, la chiave possa essere identificata da un nome di stringa in openai_key_name.

EventPayload::IssueCommentEvent(e) => {
    if e.comment.user.r#type != "Bot" {
        if let Some(b) = e.comment.body {
            if let Some(r) = chat_completion (
                    openai_key_name,
                    &format!("issue#{}", e.issue.number),
                    &b,
                    &ChatOptions::default(),
            ) {
                if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
                    write_error_log!(e.to_string());
                }
            }
        }
    }
}

Se l'evento è un nuovo problema, la funzione di flusso crea una nuova conversazione identificata da issue.numbere richiede una risposta da ChatGPT.

EventPayload::IssuesEvent(e) => {
    if e.action == IssuesEventAction::Closed {
        return;
    }

    let title = e.issue.title;
    let body = e.issue.body.unwrap_or("".to_string());
    let q = title + "\n" + &body;
    if let Some(r) = chat_completion (
            openai_key_name,
            &format!("issue#{}", e.issue.number),
            &q,
            &ChatOptions::default(),
    ) {
        if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
            write_error_log!(e.to_string());
        }
    }
}

Come distribuire la funzione di flusso senza server

Come possiamo vedere, il codice della funzione di flusso chiama le API dell'SDK per eseguire operazioni complesse. Per esempio,

  • La listen_to_event()funzione registra un URL webhook tramite l'API GitHub in modo che la handler()funzione venga chiamata quando si verificano determinati eventi in GitHub.
  • La chat_completion()funzione chiama l'API ChatGPT con la chiave API denominata e la cronologia passata/il contesto della conversazione specificata. La chiave API e la cronologia delle conversazioni sono archiviate in una cache Redis.

Il server webhook e la cache Redis sono entrambi servizi esterni da cui dipende l'SDK. Ciò significa che la funzione di flusso deve essere eseguita all'interno di un ambiente host gestito che fornisce tali servizi esterni. Flows.network è un host PaaS (Platform as a Service) per gli SDK della funzione di flusso.

Per distribuire la funzione di flusso suflows.network, devi semplicemente importare il suo codice sorgente nel PaaS.

Innanzitutto, accedi aflows.network dal tuo account GitHub. Importa il tuo repository GitHub con fork che contiene il codice sorgente della funzione di flusso e scegli "With Environment Variables".

Tieni presente che questo NON è il repository GitHub in cui desideri distribuire il bot. Questo è il repository per il codice sorgente della funzione di flusso biforcuto.

CH1nUf8

Figura 2. Importa il repository GitHub di cui hai eseguito il fork dal modello della funzione di flusso in Flows.network.

Imposta le variabili di ambiente in modo che puntino la funzione di flusso al nome della chiave API OpenAI ( open_ai_key) e al repository GitHub ( ownere repo).

GitHub ownere repole variabili qui puntano al repository GitHub in cui desideri distribuire il bot, NON al repository per il codice sorgente della funzione di flusso.

5gcTKMv

Figura 3. Impostare le variabili di ambiente per il repository GitHub in cui si desidera distribuire il bot, nonché il nome della chiave API OpenAI.

Flows.network recupererà il codice sorgente e creerà il codice sorgente di Rust nel bytecode Wasm utilizzando la cargotoolchain standard. Quindi eseguirà la funzione di flusso Wasm in WasmEdge Runtime .

Come collegare la funzione Flow a GitHub e OpenAI

Sebbene la funzione di flusso richieda connessioni alle API OpenAI e GitHub, il codice sorgente non ha chiavi API hardcoded, token di accesso o logica OAUTH. Gli SDK della funzione di flusso hanno reso facile e sicuro per gli sviluppatori interagire con i servizi API SaaS esterni.

Flows.network rileva che la funzione di flusso richiede connessioni alle API OpenAI e GitHub. Presenta flussi di lavoro dell'interfaccia utente per gli sviluppatori per:

  • Accedi a GitHub, autorizza l'accesso agli eventi e registra la funzione di flusso come webhook per la ricezione di tali eventi.
  • Associa una chiave API OpenAI al nome openai_key_name.

CpLDrub

Figura 4. I servizi esterni richiesti dalla funzione di flusso sono collegati e diventano verdi.

Una volta che le API SaaS esterne sono connesse e autorizzate, diventano verdi nel dashboard della funzione di flusso. La funzione di flusso ora riceverà gli eventi listen_to_event()per cui è. Otterrà inoltre un accesso trasparente a Redis per la chiave API OpenAI denominata e il contesto di conversazione memorizzato nella cache per supportare la chat_completion()funzione SDK.

Qual è il prossimo

Il bot GitHub è solo uno dei tanti tipi di bot che Flows.network può supportare. Collegando la funzione di flusso a un canale Slack, puoi far partecipare ChatGPT alla tua discussione di gruppo. Ecco un esempio di bot ChatGPT basato su Slack.

GitHub - rete di flussi/chat collaborativa

faviconrete di flussi GitHub

chat collaborativa

https://github.com/flows-network/collaborative-chatvoB27bjFigura 5. Il bot Slack ChatGPT.

Un altro esempio è avere ChatGPT che risponda a domande legali in un canale Slack. La funzione di flusso antepone alla domanda legale un prompt.

GitHub - rete di flussi/avvocato robo

faviconrete di flussi GitHub

robo-avvocato

https://github.com/flows-network/robo-lawyerafDM5imFigura 6. Il robo avvocato di Slack.

Oltre a GitHub e Slack, ci sono molti prodotti SaaS che puoi integrare in Flows.network tramite le loro API.

Sebbene le funzioni di flusso di esempio siano scritte in Rust, miriamo a supportare gli SDK delle funzioni di flusso basati su JavaScript. In altre parole, l'SDK della piattaforma funziona come listen_to_event()e chat_completion()avrà una versione JavaScript. La funzione di flusso JavaScript viene eseguita all'interno di WasmEdge Runtime sulla piattaforma Flows.network tramite il modulo WasmEdge-QuickJS .

Fonte: https://www.freecodecamp.org

#rust #chatbot #chatgpt

Come creare un'app ChatGPT senza server con Rust
Rust  Language

Rust Language

1679368098

How to Create a Serverless ChatGPT App with Rust

Learn how to create a Serverless ChatGPT App with Rust. Create a serverless GitHub bot. The bot is a serverless function written in Rust. The bot allows GitHub users to chat with ChatGPT and each other in GitHub Issues. 

Since OpenAI released an official API for ChatGPT in March 2023, many developers and entrepreneurs are interested in integrating it into their own business operations.

But some significant barriers remain that make it difficult for them to do this:

  • OpenAI provides a simple stateless API for ChatGPT. The developer needs to keep track of the history and context of each conversation in a cache or database managed by the application. The developer also needs to manage and safeguard the API keys. There is a lot of boilerplate code unrelated to the application’s business logic.
  • The “natural” UI for the ChatGPT API application is a threaded chat. But it is difficult to create a “chat UI” in a traditional web or app framework. In fact, the most commonly used chat UI already exists in messaging apps like Slack, Discord, and even forums (for example, GitHub Discussions). We need a simple way to connect ChatGPT API responses to an existing messaging service.

In this article, I will show you how to create a serverless GitHub bot. The bot allows GitHub users to chat with ChatGPT and each other in GitHub Issues. You can try it by asking a question, or joining another conversation thread by leaving a comment. In other words, this project uses GitHub Issues’ threaded messages UI as its own chat UI.

7eWhQ8I

Figure 1. Learning Rust with ChatGPT. see https://github.com/second-state/chat-with-chatgpt/issues/31

The bot is a serverless function written in Rust. Just fork the example, deploy your fork on flows.network, and configure it to interact with your own GitHub repos and OpenAI keys. You will have a fully functional GitHub bot in 10 minutes. There is no need to set up a web server, or a webhook for GitHub API, or a cache / database server.

How to Fork the Template Repo

First, fork this template repo from GitHub.

The src/lib.rs file contains the bot application (also known as the flow function). The run() function is called upon starting up. It listens for issue_comment and issues events from the GitHub repo owner/repo. Those events are emitted when a new issue comment or a new issue is created in the repo.

#[no_mangle]
#[tokio::main(flavor = "current_thread")]
pub async fn run() {
    // Setup variables for
    //   ower: GitHub org to install the bot
    //   repo: GitHub repo to install the bot
    //   openai_key_name: Name for your OpenAI API key
    // All the values can be set in the source code or as env vars
    
    listen_to_event(&owner, &repo, vec!["issue_comment", "issues"], |payload| {
        handler(&owner, &repo, &openai_key_name, payload)
    })
    .await;
}

The handler() function processes the events received by listen_to_event(). If the event is a new comment in an issue, the bot calls OpenAI's ChatGPT API to add the comment text into an existing conversation identified by the issue.number. It receives a response from ChatGPT, and adds a comment in the issue.

The flow function here automatically and transparently manages the conversation history with the ChatGPT API in a local storage. The OpenAI API key is also stored in the local storage so that instead of putting the secret text in the source code, the key can be identified by a string name in openai_key_name.

EventPayload::IssueCommentEvent(e) => {
    if e.comment.user.r#type != "Bot" {
        if let Some(b) = e.comment.body {
            if let Some(r) = chat_completion (
                    openai_key_name,
                    &format!("issue#{}", e.issue.number),
                    &b,
                    &ChatOptions::default(),
            ) {
                if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
                    write_error_log!(e.to_string());
                }
            }
        }
    }
}

If the event is a new issue, the flow function creates a new conversation identified by issue.number, and requests a response from ChatGPT.

EventPayload::IssuesEvent(e) => {
    if e.action == IssuesEventAction::Closed {
        return;
    }

    let title = e.issue.title;
    let body = e.issue.body.unwrap_or("".to_string());
    let q = title + "\n" + &body;
    if let Some(r) = chat_completion (
            openai_key_name,
            &format!("issue#{}", e.issue.number),
            &q,
            &ChatOptions::default(),
    ) {
        if let Err(e) = issues.create_comment(e.issue.number, r.choice).await {
            write_error_log!(e.to_string());
        }
    }
}

How to Deploy the Serverless Flow Function

As we can see, the flow function code calls SDK APIs to perform complex operations. For example,

  • The listen_to_event() function registers a webhook URL through GitHub API so that the handler() function will be called when certain events occur in GitHub.
  • The chat_completion() function calls the ChatGPT API with the named API key and past history / context of the specified conversation. The API key and conversation history are stored in a Redis cache.

The webhook server and the Redis cache are both external services the SDK depends on. That means the flow function must run inside a managed host environment that provides such external services. Flows.network is a PaaS (Platform as a Service) host for the flow function SDKs.

In order to deploy the flow function on flows.network, you simply need to import its source code to the PaaS.

First, sign into flows.network from your GitHub account. Import your forked GitHub repo that contains the flow function source code and choose "With Environment Variables".

Note that this is NOT the GitHub repo where you want to deploy the bot. This is the repo for your forked flow function source code.

CH1nUf8

Figure 2. Import the GitHub repo you forked from the flow function template into flows.network.

Set the environment variables to point the flow function to the OpenAI API key name (open_ai_key) and GitHub repo (owner and repo).

The GitHub owner and repo variables here point to the GitHub repo where you want to deploy the bot, NOT the repo for the flow function source code.

5gcTKMv

Figure 3. Set the environment variables for the GitHub repo where you want to deploy the bot, as well as the OpenAI API key name.

Flows.network will fetch the source code and build the Rust source code into Wasm bytecode using the standard cargo toolchain. It will then run the Wasm flow function in the WasmEdge Runtime.

How to Connect the Flow Function to GitHub and OpenAI

While the flow function requires connections to the OpenAI and GitHub APIs, the source code has no hardcoded API keys, access tokens, or OAUTH logic. The flows function SDKs have made it easy and safe for developers to interact with external SaaS API services.

Flows.network discovers that the flow function requires connections to the OpenAI and GitHub APIs. It presents UI workflows for the developers to:

  • Log into GitHub, authorize access to events, and register the flow function as the webhook for receiving those events.
  • Associate an OpenAI API key with the name openai_key_name.

CpLDrub

Figure 4. The external services required by the flow function are connected and turned green.

Once the external SaaS APIs are connected and authorized, they turn green on the flow function dashboard. The flow function will now receive the events it listen_to_event() for. It will also get transparent access to Redis for the named OpenAI API key and the cached conversation context to support the chat_completion() SDK function.

What's next

The GitHub bot is just one of many bot types the flows.network can support. By connecting the flow function to a Slack channel, you can get ChatGPT to participate in your group discussion. Here is an example of a Slack-based ChatGPT bot.

GitHub - flows-network/collaborative-chat

faviconflows-networkGitHub

collaborative-chat

https://github.com/flows-network/collaborative-chatvoB27bjFigure 5. The Slack ChatGPT bot.

Another example is to have ChatGPT answering legal questions in a Slack channel. The flow function prepends the legal question with a prompt.

GitHub - flows-network/robo-lawyer

faviconflows-networkGitHub

robo-lawyer

https://github.com/flows-network/robo-lawyerafDM5imFigure 6. The Slack robo lawyer bot.

Besides GitHub and Slack, there are many SaaS products you can integrate into flows.network through their APIs.

While the example flow functions are written in Rust, we aim to support JavaScript-based flow function SDKs. In another word, platform SDK functions such as listen_to_event() and chat_completion() will have a JavaScript version. The JavaScript flow function runs inside the WasmEdge Runtime on the flows.network platform through the WasmEdge-QuickJS module.

Source: https://www.freecodecamp.org

#rust #chatbot #chatgpt

How to Create a Serverless ChatGPT App with Rust
Gordon  Matlala

Gordon Matlala

1679289132

Chatbot-ui: A ChatGPT Clone for Running Locally in Your Browser

Chatbot UI

Note: Chatbot UI Pro has been renamed to Chatbot UI.

Chatbot UI is an advanced chatbot kit for OpenAI's chat models built on top of Chatbot UI Lite using Next.js, TypeScript, and Tailwind CSS.

It aims to mimic ChatGPT's interface and functionality.

All conversations are stored locally on your device.

See a demo.

Chatbot UI

Updates

Chatbot UI will be updated over time.

Expect frequent improvements.

Next up:

  •  Mobile view
  •  Saving via data export
  •  Folders
  •  Change default prompt

Recent updates:

  •  Markdown support (3/17/23)
  •  Code syntax highlighting (3/18/23)
  •  Toggle sidebar (3/18/23)
  •  Conversation naming (3/18/23)
  •  Github flavored markdown (3/18/23)
  •  Add OpenAI API key in app (3/18/23)

Modifications

Modify the chat interface in components/Chat.

Modify the sidebar interface in components/Sidebar.

Modify the system prompt in utils/index.ts.

Deploy

Vercel

Host your own live version of Chatbot UI with Vercel.

Deploy with Vercel

Replit

Fork Chatbot UI on Replit here.

Docker

docker build -t chatgpt-ui .
docker run -e OPENAI_API_KEY=xxxxxxxx -p 3000:3000 chatgpt-ui

Running Locally

1. Clone Repo

git clone https://github.com/mckaywrigley/chatbot-ui.git

2. Install Dependencies

npm i

3. Provide OpenAI API Key

Create a .env.local file in the root of the repo with your OpenAI API Key:

OPENAI_API_KEY=YOUR_KEY

4. Run App

npm run dev

5. Use It

You should be able to start chatting.

Contact

If you have any questions, feel free to reach out to me on Twitter.


Download Details:

Author: mckaywrigley
Source Code: https://github.com/mckaywrigley/chatbot-ui 
License: MIT license

#chatgpt #chatbot #ui 

Chatbot-ui: A ChatGPT Clone for Running Locally in Your Browser