Repository files navigation

👉Support this work via GitHub Sponsors

A multi-llm Emacscomint shell, byme.

• ob-chatgpt-shell: Evaluate chatgpt-shell blocks as Emacs org babel blocks.
• ob-dall-e-shell: Evaluate DALL-E shell blocks as Emacs org babel blocks.
• dall-e-shell: An Emacs shell for OpenAI’s DALL-E.
• shell-maker: Create Emacs shells backed by either local or cloud services.

chatgpt-shell goes multi model 🎉

Please sponsor the project to make development + support sustainable.

Note: With the exception ofOllama, you typically have to pay the cloud services for API access. Please check with each respective LLM service.

My favourite model is missing.

chatgpt-shell is acomint shell. Bring your favourite Emacs shell flows along.

One shell to query all. Swap LLM provider (viaM-x chatgpt-shell-swap-model) and continue with your familiar flow.

chatgpt-shell includes a compose buffer experience. This is my favourite and most frequently used mechanism to interact with LLMs.

For example, select a region and invokeM-x chatgpt-shell-prompt-compose (C-c C-e is my preferred binding), and an editable buffer automatically copies the region and enables crafting a more thorough query. When ready, submit with the familiarC-c C-c binding. The buffer automatically becomes read-only and enables single-character bindings.

Navigate through source blocks (including previous submissions in history). Source blocks are automatically selected.

Reply with with follow-up requests using ther binding.

Want to ask for more of the same data? Pressm to request more of it. This is handy to follow up on any kind of list (suggestion, candidates, results, etc).

I’m a big fan of quickly disposing of Emacs buffers with theq binding. chatgpt-shell compose buffers are no exception.

LLM being lazy and returning partial code? Presse to request entire snippet.

For quick access to common actions,chatgpt-shell provides a transient menu, powered by the excellenttransient package. Think of it as a temporary keymap overlay that pops up, shows you available commands with their keybindings, and disappears after you select one.

Invoke it withC-c C-t while inside achatgpt-shell buffer.

The menu is organized into logical groups for easy navigation:

┌──────────────────────────────────────────────────────────────────────────────┐│ Shells                          Compose prompt via              Inline edit  ││ b: Switch to shell buffer       e: Dedicated buffer             q: Quick     ││ N: Create new shell             p: Minibuffer                      insert/   ││                                 P: Minibuffer (include last        edit      ││                                    kill)                        r: Send      ││                                                                    region    ││                                                                 R: Send &    ││                                                                    review    ││                                                                    region    ││                                                                              ││ Session                         History                         Navigation   ││ m: Swap model                   h: Search                       n: Next item ││ L: Reload models                                                p: Previous  ││ y: Swap system prompt                                              item      ││                                                                 TAB: Next    ││                                                                      source  ││                                                                      block   ││                                                                 <backtab>:   ││                                                                      Previous││                                                                      source  ││                                                                      block   ││                                                                              ││ Source blocks                   Transcript                      Code Actions ││ C-c C-c: Execute                S: Save                         d: Describe  ││ E: Edit                         O: Restore                         code      ││ V: View                                                         f: Refactor  ││                                                                    code      ││                                                                 g: Write git ││                                                                    commit    ││                                                                 t: Generate  ││                                                                    unit test ││                                                                 w: Proofread ││                                                                              ││ Other                                                                        ││ C: Clear buffer                                                              ││ I: Interrupt                                                                 ││ v: Show version                                                              │└──────────────────────────────────────────────────────────────────────────────┘

(Note: The exact commands shown depend on context, like whether a region is active or if you are inside achatgpt-shell buffer.)

If you prefer a global keybinding (available everywhere in Emacs), you can add something like this to your personal Emacs configuration:

;; In your init.el or equivalent(global-set-key (kbd"C-c C-g")'chatgpt-shell-transient)

This menu helps with discovering available commands and executing them quickly without needing to remember every single keybinding orM-x command name.

Request inline modifications, with explicit confirmation before accepting.

Both the shell and the compose buffers enable users to execute source blocks viaC-c C-c, leveragingorg babel.

I’ve been experimenting with image queries (currently ChatGPT only, pleasesponsor to help bring support for others).

Below is a handy integration to extract Japanese vocabulary. There’s also a generic image descriptor available viaM-x chatgpt-shell-describe-image that works on any Emacs image (via dired, image buffer, point on image, or selecting a desktop region).

If you’re findingchatgpt-shell useful, help make the project sustainable and consider ✨sponsoring✨.

chatgpt-shell is in development. Please report issues or sendpull requests for improvements.

Finding it useful? Like the package? I’d love to hear from you. Get in touch (Mastodon /Twitter /Bluesky /Reddit /Email).

Viause-package, you can install with:ensure t.

(use-package chatgpt-shell:ensuret:custom  ((chatgpt-shell-openai-key    (lambda ()      (auth-source-pass-get'secret"openai-key")))))

(use-package shell-maker:straight (:type git:host github:repo"xenodium/shell-maker"))(use-package chatgpt-shell:straight (:type git:host github:repo"xenodium/chatgpt-shell":files ("chatgpt-shell*.el")):custom  ((chatgpt-shell-openai-key    (lambda ()      (auth-source-pass-get'secret"openai-key")))))

(setq chatgpt-shell-model-version"llama3.2")

You will first need to get an API key for each of the various public LLM endpoints you want to interact with.

You can define a function that chatgpt-shell invokes to get the API Key. The following example is for Open AI; use a similar approach for other services.

;; if you are using the "pass" password manager(setq chatgpt-shell-openai-key      (lambda ();; (auth-source-pass-get 'secret "openai-key") ; alternative using pass support in auth-sources        (nth0 (process-lines"pass""show""openai-key"))));; or if using auth-sources, e.g., so the file ~/.authinfo has this line:;;  machine api.openai.com password OPENAI_KEY(setq chatgpt-shell-openai-key      (auth-source-pick-first-password:host"api.openai.com"));; or same as previous but lazy loaded (prevents unexpected passphrase prompt)(setq chatgpt-shell-openai-key      (lambda ()        (auth-source-pick-first-password:host"api.openai.com")))

M-x set-variable chatgpt-shell-anthropic-key

M-x set-variable chatgpt-shell-deepseek-key

M-x set-variable chatgpt-shell-google-key

…

;; set anthropic key from a string(setq chatgpt-shell-anthropic-key"my anthropic key");; set OpenAI key from the environment(setq chatgpt-shell-openai-key (getenv"OPENAI_API_KEY"))

If you use ChatGPT through proxy service “https://api.chatgpt.domain.com”, set options like the following:

(use-package chatgpt-shell:ensuret:custom  ((chatgpt-shell-api-url-base"https://api.chatgpt.domain.com")   (chatgpt-shell-openai-key    (lambda ();; Here the openai-key should be the proxy service key.      (auth-source-pass-get'secret"openai-key")))))

If your proxy service API path is not OpenAI ChatGPT default path like ”/v1/chat/completions”, then you can customize optionchatgpt-shell-api-url-path.

Behind the scenes chatgpt-shell usescurl to send requests to the openai server. If you use ChatGPT through a HTTP proxy (for example you are in a corporate network and a HTTP proxy shields the corporate network from the internet), you need to tellcurl to use the proxy via the curl option-x http://your_proxy. For this, usechatgpt-shell-proxy.

For example, if you want curl-x andhttp://your_proxy, setchatgpt-shell-proxy to ”http://your_proxy”.

Launch withM-x chatgpt-shell.

Note:M-x chatgpt-shell keeps a single shell around, refocusing if needed. To launch multiple shells, useC-u M-x chatgpt-shell.

Typeclear as a prompt.

ChatGPT> clear

Alternatively, use eitherM-x chatgpt-shell-clear-buffer orM-x comint-clear-buffer.

Save withM-x chatgpt-shell-save-session-transcript and restore withM-x chatgpt-shell-restore-session-from-transcript.

Some related values stored inshell-maker likeshell-maker-transcript-default-path andshell-maker-forget-file-after-clear.

chatgpt-shell can either wait until the entire response is received before displaying, or it can progressively display as chunks arrive (streaming).

Streaming is enabled by default.(setq chatgpt-shell-streaming nil) to disable it.

There are more. Browse viaM-x set-variable

If you’d prefer your own custom display function,

(setq chatgpt-shell-display-function#'my/chatgpt-shell-frame)(defunmy/chatgpt-shell-frame (bname)  (let ((cur-f (selected-frame))        (f (my/find-or-make-frame"chatgpt")))    (select-frame-by-name"chatgpt")    (pop-to-buffer-same-window bname)    (set-frame-position f (/ (display-pixel-width)2)0)    (set-frame-height f (frame-height cur-f))    (set-frame-width f  (frame-width cur-f)1)))(defunmy/find-or-make-frame (fname)  (condition-casenil      (select-frame-by-name fname)    (error (make-frame `((name.,fname))))))

Thanks totuhdo for the custom display function.

Browse all available viaM-x.

• Please go through this README to see if the feature is already supported.
• Need custom behaviour? Check out existingissues/feature requests. You may find solutions in discussions.

Pull requests are super welcome. Pleasereach out before getting started to make sure we’re not duplicating effort. Alsosearch existing discussions.

Please share the entire snippet you’ve used to setchatgpt-shell up (but redact your key). Share any errors you encountered. Read on for sharing additional details.

Please enableM-x toggle-debug-on-error, reproduce the error, and share the stack trace.

Please enable logging(setq chatgpt-shell-logging t) and share the content of the*chatgpt-log* buffer in the bug report.

Please also share the entire org snippet.

👉 Find my work useful?Support this work via GitHub Sponsors orbuy my iOS apps.

• Blog (xenodium.com)
• Blog (lmno.lol/alvaro)
• Plain Org (iOS)
• Flat Habits (iOS)
• Scratch (iOS)
• macosrec (macOS)
• Fresh Eyes (macOS)
• dwim-shell-command (Emacs)
• company-org-block (Emacs)
• org-block-capf (Emacs)
• ob-swiftui (Emacs)
• chatgpt-shell (Emacs)
• ready-player (Emacs)
• sqlite-mode-extras
• ob-chatgpt-shell (Emacs)
• dall-e-shell (Emacs)
• ob-dall-e-shell (Emacs)
• shell-maker (Emacs)

Made withcontrib.rocks.