Baconao.NET Posts

Mobile AI and Cloud Context: Connecting Joey iOS to FastMCP on Render

Tue, 30 Jun 2026 00:00:00 -0500

End-to-End Blueprint: Connecting Intervals.icu MCP to Joey iOS via Render and OpenRouter

The Model Context Protocol (MCP) allows LLMs to interact with remote tools and data sources. While desktop clients typically rely on persistent local connections, mobile setups require an architecture optimized for short-lived, atomic network requests.

This guide outlines how to configure and link four distinct systems—Intervals.icu, Render, OpenRouter, and Joey iOS—into a stateless, single-endpoint engine to query fitness metrics and training load insights natively from your phone.

1. Intervals.icu: Extracting API Credentials

The Python MCP container acts as a direct proxy to your training logs. It requires developer authentication parameters from the Intervals.icu platform to execute queries successfully.

Log into your desktop dashboard at https://intervals.icu.
Navigate to Settings and scroll down to the API Keys section.
Locate and copy your Athlete ID (a unique identifier alphanumeric or numerical string, distinct from your public username).
Click Generate API Key. Copy the random string immediately and store it securely.

2. Render: Containerization & Transport Routing

To accept payloads from a mobile device without connection degradation, your containerized server must run a unified, stateless HTTP transport layer instead of streaming Server-Sent Events (SSE).

Step A: The Start Command

In your Render Web Service settings under Build & Deploy, swap out your default launch arguments. Force the application executable to run its native stateless HTTP configuration.

(Note: The command below uses \ to break the line so it remains fully visible on narrow screens, with no trailing backslash on the final argument):

/app/.venv/bin/intervals-icu-mcp \
  --transport streamable-http \
  --port 10000 \
  --host 0.0.0.0

Step B: Production Environment Variables

Navigate to Settings -> Environment Variables on Render. Inject the following parameters to eliminate internal state/redirect tracking loops and provide platform access:

Key	Value / Format	Architectural Purpose
`FASTMCP_STATELESS_HTTP`	`true`	Forces the FastMCP framework to process requests via individual, stateless HTTP transactions.
`FASTMCP_PATH`	`/`	Aligns the underlying server mounting layout straight to the base directory.
`INTERVALS_ICU_ATHLETE_ID`	`your_athlete_id`	Identifies your profile to the underlying application engine during API loops.
`INTERVALS_ICU_API_KEY`	`your_generated_key`	Authenticates backend calls passing through your Render proxy.

Click Save Changes. Render will automatically trigger a clean rebuild and redeploy your container.

3. OpenRouter: API Key Provisioning

Because Joey acts as a consumer interface, it passes prompt queries to a hosted language model engine. OpenRouter serves as the LLM aggregator, handling context execution and tool-calling logic.

Go to https://openrouter.ai and sign into your developer console.
Navigate to Keys -> Create Key.
Name the token contextually (e.g., Joey-MCP-Link) and generate it. Copy the string immediately. Ensure your account balance contains credits to handle tool-calling inference loops.

4. Joey iOS: Endpoint Consolidation

With the cloud infrastructure running a unified HTTP transport layer, input the final routing configuration parameters directly into your iOS mobile client.

Step A: LLM Setup

In the Joey settings panel, paste your newly generated OpenRouter API token into the provider configurations and select an intelligent, tool-capable model (such as Anthropic’s Claude 3.5 Sonnet or OpenAI’s GPT-4o).

Step B: Server Integration

Tap MCP Servers -> Add Server and configure the endpoint fields exactly as specified below:

URL: https://intervals-icu-mcp-2j3k.onrender.com/mcp (Note: Do not include an additional trailing slash at the absolute end of the URL string).
Custom Headers:
- Key: Authorization
- Value: Bearer your_chosen_mcp_access_token

Connection Verification

When Joey saves the configuration, it initiates a single POST handshake request to the server. The proxy validates the Authorization header, maps the payload to the stateless engine, and returns a successful connection status in your Render logs:

INFO:     31.154.8.117:0 - "POST /mcp HTTP/1.1" 200 OK

The status indicator inside Joey will illuminate green, confirming that the LLM now has full visibility of your custom Intervals.icu tools.

Using Local AI Agents to Analyze Personal Fitness Data

Sun, 21 Jun 2026 00:00:00 -0500

💻 Using Local AI Agents to Analyze Personal Fitness Data

Model Context Protocol (MCP) and AI agents are frequently discussed in the context of enterprise software development. However, these tools are also highly effective for personal hobbies and data analysis.

I wanted a way to query my cycling and recovery metrics securely without relying on premium AI subscriptions. By combining open-source tools and custom inference endpoints, I built a local training assistant for free.

The Setup

The Data Source: Intervals.icu Tracks fitness metrics like training load, fatigue, and form (CTL/ATL/TSB) and provides an open API.
The Terminal: Warp Warp’s AI Agent natively supports MCP. I configured a local MCP server (intervals-icu-mcp) to let the terminal communicate directly with the API.
The LLM: OpenRouter To bypass standard platform credit limits, I used Warp’s “Bring Your Own Inference” capability to connect to OpenRouter, routing queries through free models like Qwen or Llama.

The Workflow

I can open the AI panel in my terminal and ask:

“Analyze my training load from this week. Based on my current injury recovery, should I take a rest day tomorrow?”

The agent fetches the real-time data via the local MCP server, processes it through OpenRouter, and returns a data-driven recovery recommendation in seconds.

Using local tools and open APIs makes it straightforward to build custom, private data pipelines for any hobby.

#AI #ModelContextProtocol #DataScience #WarpTerminal #OpenRouter #FitnessTech

Install WhatsApp on Mac with Nativefier

Sun, 19 Apr 2026 00:00:00 -0500

WhatsApp has an official Mac app, but it can be heavy on resources and sometimes lacks flexibility. An alternative is to wrap WhatsApp Web into a standalone desktop app using Nativefier.

What is Nativefier?

Nativefier is a command-line tool that creates a desktop application from any web page using Electron. It gives you a lightweight, standalone window without the overhead of a full browser.

Prerequisites

You need Node.js and npm installed. If you don’t have them, install via Homebrew:

brew install node

Install Nativefier

npm install -g nativefier

Create the WhatsApp App

Run the following command:

nativefier --name "WhatsApp" "https://web.whatsapp.com" --single-instance

This will generate a folder in your current directory containing the .app bundle.

Useful options

--icon icon.png - Use a custom icon (download a WhatsApp icon in .png format first)
--single-instance - Prevents opening multiple instances
--internal-urls ".*whatsapp.*" - Keeps all WhatsApp-related navigation inside the app
--darwin-dark-mode-support - Enables dark mode support on macOS

A more complete example:

nativefier \
  --name "WhatsApp" \
  --single-instance \
  --internal-urls ".*whatsapp.*" \
  --darwin-dark-mode-support \
  "https://web.whatsapp.com"

Move the App to Applications

mv WhatsApp-darwin-*/WhatsApp.app /Applications/

You can now launch WhatsApp from Spotlight or your Applications folder. On first launch, scan the QR code with your phone to link the session, just like you would in the browser.

Notes

Nativefier is archived - The project is no longer actively maintained but still works. An actively maintained alternative is Pake.
The app stores its session data locally, so you won’t need to re-scan the QR code every time.
To update the app, simply re-run the nativefier command and replace the old .app bundle.

Warp - Shell with an AI attitute

Tue, 01 Apr 2025 00:00:00 -0500

Do you like using shells: sh, cmd, ps
Do you feel forgetting how to do things, like what's the command to remove all directories and sub and force and and recursive and all?
Do you like AI or talking to AI, or just want to say you are AI aware?

Then, my very serious recomendation:

Go Warp a very neat, cool, easy-to-use, and powerful command line (shell) tool, with AI built-in

https://www.warp.dev/terminal

Setting up GitHub Pages

Tue, 28 Jan 2025 00:00:00 -0600

GitHub allows you to host pages directly from your repo Here are the steps I did: For GitHub:

Create a repository for your project (you can name it anything).
Add your HTML file (e.g., index.html) to the repository.
Go to the repository’s Settings > Pages.
In the Source section, select the branch where your HTML file is located, and choose the root folder.
GitHub will provide you with a link to access your hosted HTML page.

Fedora Server on Minix NEO Z64W

Tue, 31 Oct 2023 00:00:00 -0500

The Minix NEO Z64-W is intended to run Windows, but, since it has an Intel chipset, it runs Linux Server pretty well. Until a few days ago, I had a stable version of Ubuntu Server 20 LTS running there. A failed attempt to upgrade to Ubuntu LTS 22 brings me here.

The preparation process is straighforward:

Download Fedora Server iso image
Use Rufus to create bootable USB drive
Disable Bit Execute on the BIOS to boot from the USB drive
Next, Next, Next (be sue to enable root for ssh if you intend to use it headless)

Warning: dnf upgrade broke the whole installation, so I had to start over

Stuff I installed

dnf install nano samba git qbitorrent-nox pip3 nfs-utils

Mounting External USB Drives

mkdir /media/external /media/backup
mount /dev/sda1 /media/external
mount /dev/sda2 /media/backup
blkid /dev/sda1
cp /etc/fstab /etc/fstab.backup

nano /etc/fstab

UUID=384A8DB912EAB6E6 /media/backup auto nosuid,nodev,nofail 0 0
UUID=96A803ADA8038AC7 /media/external auto nosuid,nodev,nofail 0 0

NFS Configuration for everyone

systemctl enable --now rpcbind nfs-server
systemctl start nfs-server

nano /etc/exports

/media/external/transmission 192.168.1.0/24(rw,sync,insecure,all_squash,anonuid=0,anongid=0)
/media/backup 192.168.1.0/24(rw,sync,insecure,all_squash,anonuid=0,anongid=0)

exportfs -ra

Disable Firewall

systemctl stop firewalld
systemctl disable firewalld

Reloading USB after unplugging the extenal drive

Check disk ‘ sudo fdisk -l | grep sd ‘

List USB devices: ‘ lsblk -f ‘

Moving from Android to iPhone

Wed, 31 May 2023 00:00:00 -0500

After several years on Android, I moved recently to iPhone. Here are my takes on the process

Android history: Galaxy 2, Galaxy 4, Galaxy 6, Pocofone, Pixel 4 XL Moving to: iPhone 14 Max

What I like

Smoothness, both switching apps and within apps
Font control over particular apps
Apple Pay
Car Play
Silent physical button

What I miss

Trusted device/location to unlock device
Google News integrated on swipe right
Scan to PDF to Google Drive
Control over audio control
Built-in Translation to Hebrew
Multi language assistant - Siri works with only one language

What’s very similar and not worth moving for

Camera
Battery life
Audio quality

Calling AWS Lambda functions from LINQPad

Tue, 03 Jan 2023 00:00:00 -0600

Open LINQPad
Add reference to JSON.NET
Use this C# statement to call a Lambda function in AWS:

 var lambdaUrl = "https://<base>.amazonaws.com/default/<api>";

var message = "some message";
var data = new { message };
var payloadJson = JsonConvert.SerializeObject(data);

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, lambdaUrl);
request.Content = new StringContent(payloadJson, Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);

Console.WriteLine(await response.Content.ReadAsStringAsync());

In order to create/configure the lambda function, follow these steps:

Login to AWS
Search for Lambda
Create new function
- Select existing permission lambda_execution
Go to Configuration
- Create New trigger of type API Gateway
- Set Security to None

Grep - Powershell style

Sun, 09 Jan 2022 00:00:00 -0600

Use this powershell command to find text in files, grep style:

 gci -r | sls 'some text'

 Get-ChildItem -Recurse | Select-String 'some text'

Fix apt upgrade error when connecting to fr.archive.ubuntu.com

Fri, 03 Dec 2021 00:00:00 -0600

Recently, when trying to upgrade my tiny Ubuntu Server, got this error:

Failed to fetch http://fr.archive.ubuntu.com/ubuntu/dists/focal-updates/InRelease  Cannot initiate the connection to fr.archive.ubuntu.com:80 (2001:bc8:1600:4:63f:72ff:feaf:a2de). - connect (101: Network is unreachable)

I thought that the issue was related to IPv6, so I disabled it:

nano /etc/sysctl.conf1

Add:

net.ipv6.conf.all.disable_ipv6 = 1
net.ipv6.conf.default.disable_ipv6 = 1
net.ipv6.conf.lo.disable_ipv6 = 1

Run sysctl -p

Confirm cat /proc/sys/net/ipv6/conf/all/disable_ipv6 It should return 1 (disabled)

This didn’t help (also got error with IPv4)

W: Failed to fetch http://fr.archive.ubuntu.com/ubuntu/dists/focal/InRelease  Could not connect to fr.archive.ubuntu.com:80 (51.158.154.169), connection timed out

So, after doing a ping to fr.archive.ubuntu.com and confirming it’s down, just replaced it with us.archive.ubuntu.com:

nano /etc/apt/sources.list

Finally packages upgrade is running

apt-get update
apt upgrade