3076 /usr/local/bin/llama-server --rerank -m /mnt/nvme0n1/LLM/quantized/bge-reranker-v2-m3-q8_0.gguf -v -c 8192 -ub 2048 --log-timestamps --host 192.168.1.68 --port 7676
144022 /usr/local/bin/llama-server -ngl 999 -v -c 8192 -ub 1024 --embedding --log-timestamps --host 192.168.1.68 --port 9999 -m /mnt/nvme0n1/LLM/nomic-ai/quantized/nomic-embed-text-v1.5-Q8_0.gguf
144235 /usr/local/bin/llama-server --jinja -fa on -c 32768 -ngl 64 -v --log-timestamps --host 192.168.1.68 -ub 512 --threads 16 --embeddings --webui-mcp-proxy --pooling mean --reasoning off -m /mnt/nvme0n1/LLM/quantized/Qwen3.6-35B-A3B-UD-Q3_K_XL.gguf --mmproj /mnt/nvme0n1/LLM/quantized/Qwen3.6-35B-A3B-mmproj-F16.gguf

pgrep -fa image
2963 /bin/bash -x /home/data1/protected/bin/rcd/rcd-llm-start-image-embeddings-model.sh
pgrep -fa vision  
3066 python /mnt/data/LLM/nomic-ai/nomic-embed-vision-v1.5-api.py

(defun rcd-llm (&optional prompt)
  "Send PROMPT to your locally running LLM and handle the response intelligently.

This is your Swiss Army knife for LLM interaction in Emacs. It respects
the four freedoms by working exclusively with your local models.

How to use it:

- Just call it with no prefix: replaces the selected region with the LLM's response
- `C-u` (one prefix): inserts the response AFTER the current region or cursor
- `C-u C-u` (two prefixes): copies the response to kill ring (memory) without inserting
- `C-u C-u C-u` (three prefixes): pops up a new buffer showing both prompt and response

What it does automatically:

1. Grabs any selected text as context (using `rcd-region-string`)
2. Adds your user memory if you've enabled it (so the LLM remembers your preferences)
3. Asks you for a prompt if you didn't provide one
4. Intelligently combines your prompt with any selected region
5. If you've enabled function calling, it handles tool calls in a loop (up to 5 rounds)
6. Logs everything so you can audit what the LLM did
7. Adds both your prompt and the response to the LLM's memory for conversation continuity
8. Can speak \"Finished\" when done if you like audio feedback

The real magic is in the context handling around line 80 or so—when you hit `C-u C-u` with a region selected, it actually grabs text before and after your selection, building a full context window. The LLM sees what came before, what comes after, and ONLY modifies the middle part. Perfect for editing inside existing text.

It uses whatever LLM you've configured in `rcd-llm-users-llm-function`, so you can swap models freely. No vendor lock-in. No surveillance.

The prefix argument conditions (around line 100-150) give you precise control:

- Region + C-u → insert response after region
- Region + C-u C-u → copy response to kill ring  
- Region + three prefixes → pop up report buffer
- Otherwise → replace region or just insert

And if your buffer is read-only? It gracefully falls back to showing the response in a separate window.

This is what software freedom looks like—I can modify this function, share it with friends, run it on any computer I own, and nobody can take it away from me."
  (interactive)
  (let* ((region (rcd-region-string))
     (memory (when rcd-llm-use-users-llm-memory (rcd-llm-user-memory)))
     (original-prompt (or prompt (rcd-ask rcd-llm-prompt)))
     (output-prompt (cond (rcd-llm-show-prompt original-prompt)
                  (t nil)))
     ;; Process prompt with region (without adding function prompts)
     (user-prompt (cond ((and region
                   (not (string-empty-p original-prompt)))
                 (concat (string-add original-prompt ":\n\n") region))
                ((not (string-empty-p original-prompt)) original-prompt)
                ((and region
                  (string-empty-p original-prompt))
                 region)
                (t nil)))
     ;; Get tools JSON if functions are enabled
     (tools-json (when rcd-llm-use-functions (rcd-llm-tools-json)))
     (rcd-message-date nil)
     ;; Store the LLM function to use
     (llm-func (cond ((and (boundp 'rcd-llm-users-llm-function) 
                                (functionp rcd-llm-users-llm-function)) 
                          rcd-llm-users-llm-function)
                         (t (error "Could not find a model. Missing model setup?"))))
         ;; Get system message for follow-up calls
         (system-message (when rcd-llm-use-functions
                           (or (rcd-db-get-entry "llmmodels" "llmmodels_systemmessage" 
                                                (rcd-db-users-defaults "llmmodels") rcd-db)
                              "You are helpful assistant."))))
    
    (cond (user-prompt
       (rcd-message "Requesting LLM...")
       (let* ((initial-response (funcall llm-func user-prompt memory nil nil nil nil nil nil nil tools-json))
          (response initial-response)
          (max-tool-calls 5)  ; Prevent infinite loops
          (tool-call-count 0))
             
         ;; Handle tool calls in a loop (multiple rounds if needed)
         (while (and rcd-llm-use-functions
                         response
                         (rcd-llm-has-tool-calls-p response)
                         (< tool-call-count max-tool-calls))
               (setq tool-call-count (1+ tool-call-count))
               
               ;; Execute tool calls and get results
               (let ((tool-results (rcd-llm-execute-tool-calls response)))
                 (when tool-results
                   ;; Build messages with system message and tool results
                   (let* ((tool-messages (rcd-llm-build-messages-with-tools 
                                         user-prompt tool-results))
                          (full-messages (vconcat
                                         `[((role . "system") 
                                            (content . ,system-message))]
                                         tool-messages))
                          ;; Prepare arguments for follow-up call
                          (args (list nil memory nil nil nil nil nil nil nil  ; prompt through stream
                                      nil  ; tools-json (none)
                                      (json-encode full-messages))))  ; messages-json
                     ;; Call with apply to ensure correct number of arguments
                     (setq response (apply llm-func args))))))
         
         (cond (response
            (rcd-log-llm user-prompt response)
            (cond 
             
              ((and (equal (prefix-numeric-value current-prefix-arg) 5)
                (called-interactively-p))

              (let* ((context (rcd-region-with-context))
                 (before (nth 0 context))
                 (region (nth 1 context))
                 (after (nth 2 context))
                 (full-prompt
                  (format
                   "## Context before (text before):\n\n%s\n\n## === MAIN CONTEXT BEGIN (this is text in middle)===\n%s\n=== END MAIN CONTEXT ===\n\nContext after (this is text that is after main):\n\n%s\n\n## INSTRUCTION\n\nYou must act on the main context, while knowing what as before, and what comes after in the text. Your instruction: %s"
                   before region after user-prompt))
                 (middle-response (funcall llm-func full-prompt memory nil nil nil nil nil nil nil tools-json)))
            (when middle-response
              (rcd-log-llm full-prompt middle-response)
              (insert middle-response))))

             ;; when there is region
             ((and region
               (called-interactively-p)
               ;; When one C-u
               (eql (car current-prefix-arg) 4)) 
              (goto-char (cdar (region-bounds)))
              (setq deactivate-mark t)
              (cond (buffer-read-only 
                 (rcd-message "Buffer is read-only, showing response in separate window")
                 (rcd-llm-pop-report llm-func output-prompt response))
                (t (insert "\n\n" response "\n\n"))))

             ;; When region and two C-u
             ((and region
               (called-interactively-p)
               ;; When two C-u
               (eql (car current-prefix-arg) 16))
              (setq deactivate-mark t)
              (rcd-kill-new response))
                  
             ;; with 3 x C-u open buffer
             ((or (and (eql (car current-prefix-arg) 64)
                   (called-interactively-p))
              rcd-llm-pop-to-window)
              (rcd-llm-pop-report llm-func user-prompt response))

             ;; otherwise if region 
             ((and region (called-interactively-p))
              (cond ((not buffer-read-only) (rcd-region-string-replace response))
                (t (rcd-llm-pop-report llm-func output-prompt response))))

             ;; if called interactively, insert into buffer
             ((called-interactively-p) 
              (cond ((not buffer-read-only) (insert response))
                (t (rcd-llm-pop-report llm-func output-prompt response))))

             ;; otherwise just return response
             (t response))
            
            ;; Handle memory
            (when (and rcd-llm-add-to-memory rcd-llm-use-users-llm-memory)
              (hyperscope-add-to-column (rcd-db-current-user-llm-memory) "hyobjects_text" user-prompt)
              (hyperscope-add-to-column (rcd-db-current-user-llm-memory) "hyobjects_text" response))
            
            (setq rcd-llm-last-response response)
            
            (when rcd-llm-speak
              (when rcd-speech
            (rcd-tts-and-speak "Finished.")))
            
            ;; Return or kill response
            (cond ((called-interactively-p) (rcd-kill-new response))
              (t response)))
           
           (t (prog2 (rcd-warning-message "Could not reach LLM server") nil)))))
           (t (rcd-warning-message "LLM: Empty Prompt")))))