Practical LLM Applications on the Linux Command Line

Essential excerpt · discover and select a local model

models=$(ollama list | awk -F' ' '{print $1}')
options=($models)

PS3="Please select a model: "
select model in "${options[@]}"; do
    if [[ -n $model ]]; then
        break
    fi
    echo "Invalid option. Please select a valid model."
done

Essential excerpt · invoke Ollama through a Unix pipe

cat "$1" | ollama run "$model" > result.txt

Essential excerpt · common load_model()

MODELS_FILE="$HOME/models.txt"
MODEL=""

load_model()
{
    local script_name=${0##*/}

    [ -f "$MODELS_FILE" ] || {
        echo "Fehler: Modelldatei '$MODELS_FILE' nicht gefunden." >&2
        exit 1
    }

    MODEL=$(awk -v key="$script_name" '
        index($0, key ":") == 1 {
            print substr($0, length(key) + 2)
            exit
        }' "$MODELS_FILE")

    [ -n "$MODEL" ] ||
        MODEL=$(awk '
            index($0, "default:") == 1 {
                print substr($0, 9)
                exit
            }' "$MODELS_FILE")

    [ -n "$MODEL" ] || exit 1
}

Essential excerpt · constructing the OpenCode invocation

load_model
prompt="$*"

args=(run -m "$MODEL" "$prompt")

if [ -n "$file" ]; then
    args+=(-f "$file")
fi

opencode "${args[@]}"

Essential excerpt · task-specific vision prompt

opencode run \
    -m "$MODEL" \
    'Identify the plant shown in this image.
     Give the most likely German common name first,
     followed by the scientific name in parentheses
     if you can determine it reliably.
     If the identification is uncertain, say so and
     give the most likely alternatives.
     Output only the identification.' \
    -f "$file" \
    > "$out"

Remote-local MCP over SSH

The MCP client does not have to run on the Outlook machine. A client such as OpenCode can run on a separate host A and start the stdio MCP server remotely on host B through SSH. OpenCode still treats the process as a local MCP command: its stdin and stdout are connected to ssh, while SSH transparently carries the MCP stdio stream to outlookmcp.py on the remote WSL2 system. The Outlook bridge remains local to host B and does not need to be exposed or forwarded to host A.

+---------------------------+
| Host A                    |
|                           |
|  OpenCode                 |
|     |                     |
|     | MCP over stdio      |
|     v                     |
|  ssh remoteuser@wsl-host  |
+-------------|-------------+
              |
              | encrypted SSH connection
              | stdin / stdout
              v
+-------------|--------------------------------------+
| Host B / WSL2                                    |
|                                                  |
|  outlookmcp.py                                   |
|     |                                            |
|     | local TCP / JSON-lines                     |
|     v                                            |
|  Windows-side Ruby bridge                        |
|  outlookservermcp.rb                             |
|     |                                            |
|     | Win32OLE / COM                             |
|     v                                            |
|  Outlook.exe                                     |
|  mailbox + calendar                              |
+--------------------------------------------------+

No Outlook bridge port is forwarded to host A.
SSH transports only the MCP server's stdio stream.

OpenCode configuration on host A

The remote MCP server is configured as a normal local command. The command executed by OpenCode is simply ssh; the remaining arguments select the remote host, the Python interpreter from the remote virtual environment and the MCP server script.

{
  "mcp": {
    "outlook": {
      "type": "local",
      "command": [
        "ssh",
        "remoteuser@wsl-host",
        "/home/remoteuser/app/outlook/.venv/bin/python3",
        "/home/remoteuser/app/outlook/outlookmcp.py"
      ],
      "enabled": true
    }
  }
}

A manual smoke test is equivalent to running ssh remoteuser@wsl-host /home/remoteuser/app/outlook/.venv/bin/python3 /home/remoteuser/app/outlook/outlookmcp.py. If the command remains attached without producing ordinary output, the stdio MCP server is waiting for protocol messages as expected.

Essential excerpt · MCP adapter and transport

from mcp.server.mcpserver import MCPServer

HOST = os.environ.get("OUTLOOK_MCP_HOST", "<WINDOWS_WSL_INTERFACE_IP>")
PORT = int(os.environ.get("OUTLOOK_MCP_PORT", "<OUTLOOK_BRIDGE_PORT>"))

mcp = MCPServer("outlook")

def _call(cmd: str, **params):
    request = {"cmd": cmd, **params}
    with socket.create_connection((HOST, PORT), timeout=30) as sock:
        sock.sendall((json.dumps(request) + "\n").encode("utf-8"))
        # receive one JSON-line response ...
    # validate {"ok": ...} and return response["data"]

Essential excerpt · MCP tools map directly to bridge commands

@mcp.tool()
def get_mail(entry_id: str) -> dict:
    return _call("get_mail", entry_id=entry_id)

@mcp.tool()
def create_mail(to: list[str], subject: str, body: str,
                cc: list[str] | None = None) -> dict:
    return _call("create_mail", to=to, cc=cc or [],
                 subject=subject, body=body)

@mcp.tool()
def send_mail(entry_id: str) -> dict:
    return _call("send_mail", entry_id=entry_id)

Essential excerpt · combined natural-language-friendly search

@mcp.tool()
def search(folder="inbox", sender=None, recipient=None,
           subject=None, date_from=None, date_to=None, limit=30):
    return _call("search", folder=folder,
                 sender=sender, recipient=recipient, subject=subject,
                 date_from=date_from, date_to=date_to, limit=limit)

Essential excerpt · stateless JSON-lines bridge

HOST    = "<WINDOWS_WSL_INTERFACE_IP>"
PORT    = <OUTLOOK_BRIDGE_PORT>
MAILBOX = "<MAILBOX_ADDRESS>"

$server = TCPServer.new(HOST, PORT)
loop do
  client = $server.accept
  while (line = client.gets)
    request  = JSON.parse(line.strip)
    response = handle(request)
    client.puts(JSON.generate(response))
  end
ensure
  client.close rescue nil
end

Essential excerpt · attach to Outlook through Win32OLE

begin
  $outlook = WIN32OLE.connect('Outlook.Application')
rescue
  $outlook = WIN32OLE.new('Outlook.Application')
end

WIN32OLE.const_load($outlook, OutlookConst)
$ns  = $outlook.GetNamespace("MAPI")
$top = $ns.Folders.Item(MAILBOX)

Essential excerpt · stable addressing and safe draft-before-send workflow

# Read an existing item by Outlook EntryID
mail = $ns.GetItemFromID(req["entry_id"], $top.StoreID)

# Create and save a draft first
mail = $outlook.CreateItem(OutlookConst::OlMailItem)
mail.Subject = req["subject"].to_s
mail.Body    = req["body"].to_s
mail.Save

# Sending is a separate operation on that draft
mail = $ns.GetItemFromID(req["entry_id"], $top.StoreID)
mail.Send

Essential excerpt · SSH-friendly bridge control from WSL2

RUBY_EXE="/mnt/c/Program Files/Ruby34-x64/bin/ruby.exe"
HOST="<WINDOWS_WSL_INTERFACE_IP>"
PORT="<OUTLOOK_BRIDGE_PORT>"

nohup "$RUBY_EXE" outlookservermcp.rb > "$LOGFILE" 2>&1 &
echo $! > "$PIDFILE"
disown

timeout 3 bash -c "echo > /dev/tcp/$HOST/$PORT"

Example requests on the bridge protocol

{"cmd":"list_mails","folder":"inbox","limit":10,"unread_only":true}
{"cmd":"search","folder":"inbox","subject":"<SEARCH_TERM>","date_from":"<YYYY-MM-DD>","date_to":"<YYYY-MM-DD>"}
{"cmd":"get_mail","entry_id":"<OUTLOOK_ENTRY_ID>"}
{"cmd":"create_mail","to":["<RECIPIENT>"],"subject":"<SUBJECT>","body":"<BODY>"}
{"cmd":"send_mail","entry_id":"<OUTLOOK_ENTRY_ID>"}
{"cmd":"list_calendar","from":"<YYYY-MM-DD>","to":"<YYYY-MM-DD>"}

Switching provider without changing the script

# Hosted gateway
myopenrouterocr:openrouter/qwen/qwen3-vl-8b-instruct

# Alternative: OpenCode Zen
myopenrouterocr:opencode/<vision-model>

# Alternative: locally configured Ollama provider in OpenCode
myopenrouterocr:ollama/<vision-model>