Faster and more efficient ways to switch backends/directives?

[karthink]

From @LazerJesus (#177)

---

with this gptel becomes even more important to my daily work. i love it!
i got a couple of questions, not sure if here is the best spot, so let me know if i should start a new issue about any of these.

managing multiple backends

at the moment i toggle models by keybinding custom expressions. like this

  (defun set-gpt4-universal ()
    (interactive)
    (setq gptel-model "gpt-4-1106-preview")
    (setq chatgpt-shell-chatgpt-model-version "gpt-4-1106-preview"))

  (defun gptel-with-argument ()
    (interactive)
    (setq current-prefix-arg '(4))
    (call-interactively #'gptel))

  (general-menu "ai" "a"
    "r" '(gptel-send :wk "gptel region")
    "R" '(gptel-send-with-argument :wk "gptel region prefixed")
    "a" '(gptel-abort :wk "abort")
    "C-<return>" '(gptel-send-with-argument  :wk "gptel send prefixed")
    "3" '(set-gpt3-universal  :wk "gpt 3.5 turbo")
    "4" '(set-gpt4-universal  :wk "gpt 4"))

but with multiple backends that is becoming tedious. is there a better way?

whats the fastest way to provide one-off directives

i often highlight text regions and want to write just a few words as directive.
using the gpt-system buffer (reached via h h from the gptel minibuffer) is about 8 key hits for me.
open minibuffer, h h, closing minibuffer, clearing text, c-c c-c.
is there a faster way?

managing directives / directives per model?

different models have different strengths and weaknesses, therefore i use them for different reasons.
for example, i use gpt4 for coding and mixtral for summarizing large bodies of text.
that requires different directives. is it possible to have directives per model?
how would i do that?

[karthink]

There are many ways to speed up switching between models/backends/directives -- gptel's defaults try to be simple and discoverable, not fast.

Ranked easy to involved, you could try:

Keyboard macros

using the gpt-system buffer (reached via h h from the gptel minibuffer) is about 8 key hits for me: open minibuffer, h h, closing minibuffer, clearing text, c-c c-c.

Most sequences of keys can be automated easily. Assuming your leader key is SPC, you could do

(keymap-global-set "<f6>" "SPC u SPC a r h h d")

to jump to the directive editor. SPC u is the prefix arg, SPC a r your keybinding for gptel-send, h h to open the editor, and d (assuming evil-mode) to clear the pre-selected region.

You can set up keyboard macros for other things too, like switching to gpt-4:

(keymap-global-set "SPC a 4" "SPC u SPC a r - m c h a <return> 4 <return>")

Call gptel functions directly

The transient menu is available at M-x gptel-menu, you can bind to it directly. The directives menu can be accessed directly at M-x gptel-system-prompt. You can also include these in the above keyboard macros as "<<gptel-menu>>", etc.

Helper functions

but with multiple backends that is becoming tedious. is there a better way?

How is what you're doing (to switch between gpt-4 and gpt-3.5) tedious? It's just one keybinding?

To be safe, you should be setting the backend along with the model.

for example, i use gpt4 for coding and mixtral for summarizing large bodies of text. that requires different directives. is it possible to have directives per model? how would i do that?

If you know these combinations ahead of time, you can do something like this:

(defvar my/gptel-presets
  ;; PRESET NAME         MODEL           BACKEND NAME   DIRECTIVE      
  '(("gpt4+coding"       "gpt-4"         "ChatGPT"      "My coding directive for gpt-4")
    ("mixtral+summarize" "Mixtral..."    "anyscale"     "My directive for summarizing with Mixtral")
    ("gpt-3.5+general"   "gpt-3.5-turbo" "ChatGPT"      "My directive for gpt-3.5"))
  "List of preset combinations for gptel.")

(defun my/gptel-switch-preset (preset)
  (interactive (list (completing-read
                      "Select preset: "
                      (mapcar #'car my/gptel-presets)
                      nil t)))
  (let ((combination (assoc preset my/gptel-presets)))
    (setq gptel-model (nth 1 combination)
          gptel-backend (cdr (assoc (nth 2 combination) gptel--known-backends))
          gptel--system-message (nth 3 combination))
    (message "Selected gptel preset: %s" preset)))

NOTE: This can break in the future as it accesses internal gptel variables (gptel--system-message, gptel--known-backends).

Custom gptel queries with gptel-request

whats the fastest way to provide one-off directives

For custom workflows, gptel provides gptel-request. See the wiki for examples.

Here's a function that asks you for a directive, sends the current region (or text before point if there's no selected region) and inserts the response below the region:

(defvar my/gptel-directive-history nil
  "Store history of chosen gptel directives.")

;; Optional: persist history across Emacs sessions
(add-to-list 'savehist-additional-variables 'my/gptel-directive-history)

(defun my/gptel-send-with-directive (directive)
  (interactive (list (completing-read
                      "Directive for region: "
                      (mapcar #'cdr gptel-directives)
                      nil nil nil my/gptel-directive-history)))
  (gptel-request nil :system directive))

You can tweak it to do what you want, see the documentation of gptel-request.