How do I use Karmic Gochara MCP Server?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Karmic Gochara MCP Server get my transits for today based on my birth date 1990-05-15" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

Karmic Gochara MCP Server

by tripesinn

Overview Schema Source Related Servers Discussions Admin

Python

Hybrid

🌌 Karmic Gochara MCP Server

Real-time astrological transit calculations and synthetic evolutionary doctrine readings, exposed via the Model Context Protocol (MCP) for Google AI Edge Gallery.

Status MCP License Made with Local

Live endpoint: http://34.163.125.49:8000 Schema discovery: http://34.163.125.49:8000/mcp/discovery

⚡ Quick Start

Test the live endpoint in 10 seconds:

# 1. Health check
curl http://34.163.125.49:8000/health
# → {"status":"ok","service":"karmic-lite-mcp-server"}

# 2. Get planetary transits for a date of birth
curl "http://34.163.125.49:8000/transits/today?dob=1990-05-15"
# → {"date":"1990-05-15","planet_positions":{"sun":"...","moon":"..."}}

# 3. Request a doctrine reading
curl -X POST "http://34.163.125.49:8000/doctrine/reading?dob=1990-05-15&birth_time=14:30" \
  -H "Content-Type: application/json" -d '{}'
# → {"reading":"...","input_details":{"dob":"...","birth_time":"..."}}

Related MCP server: Retrograde MCP

🎯 What is this?

The Karmic Gochara MCP Server is a lightweight FastAPI microservice that exposes astrological calculations through the Model Context Protocol (MCP), making them directly callable by on-device LLMs like Gemma-4-E4B-it running inside Google AI Edge Gallery on Pixel devices.

It currently ships 3 MCP tools (designed to stay within the context window of small local models):

Tool	Purpose	Input	Output
`get_natal_chart`	Birth chart positions	`dob`, `birth_time`, `birth_place`	Sun, Moon, Ascendant, planets, nodes
`get_transits_today`	Current planetary aspects	`natal_data`, `tz`	Aspect list, intensity score, dominant planet
`get_doctrine_reading`	Synthetic evolutionary reading	`natal_data`, `transits_data`, `question?`	JSON with 4 doctrinal pillars + insight

🛠️ Architecture

┌─────────────────────┐         HTTP/MCP          ┌──────────────────────────┐
│  Pixel 9 + Edge     │  ──────────────────────►  │  FastAPI MCP Server      │
│  Gallery + Gemma-4  │  ◄──────────────────────  │  (GCP e2-small, Paris)   │
└─────────────────────┘                           └──────────────────────────┘
                                                          │
                                                          ▼
                                                  ┌──────────────────┐
                                                  │  pyswisseph      │
                                                  │  geopy           │
                                                  │  (Swiss Ephemeris│
                                                  │   ephemerides)   │
                                                  └──────────────────┘

Stack: Python 3.10 · FastAPI 0.104 · Pydantic 2.5 · Uvicorn 0.27 · pyswisseph 2.10 · geopy 2.4

🚀 Local Development

Prerequisites

Python 3.10+
Git

Setup

# Clone
git clone https://github.com/tripesinn/karmic-mcp.git
cd karmic-mcp

# Create virtual environment
python3 -m venv venv
source venv/bin/activate

# Install dependencies
pip install -r requirements.txt

# Run server
python server.py
# → Server runs on http://0.0.0.0:8000

Test locally

bash test_client.sh

Expected output:

✅ PASS: Health check returned HTTP 200.
✅ PASS: Transits endpoint returned structured data.
✅ PASS: Doctrine reading endpoint returned structured data.
🚀 MISSION SUCCESS: Local API Validation Complete.

☁️ Deployment (GCP Compute Engine)

This server runs on a GCP e2-small instance (Ubuntu 22.04, europe-west9-a) as a systemd service.

Deploy from scratch

# 1. SSH into your VM
gcloud compute config-ssh  # one-time setup
ssh dev-vm

# 2. Install Python venv system package
sudo apt install -y python3.10-venv python3-pip

# 3. Clone the repo
cd ~ && git clone https://github.com/tripesinn/karmic-mcp.git
cd karmic-mcp

# 4. Setup venv + install deps
python3 -m venv venv
source venv/bin/activate
./venv/bin/python -m ensurepip --default-pip
./venv/bin/pip install -r requirements.txt

# 5. Create systemd service
sudo tee /etc/systemd/system/karmic-mcp.service > /dev/null <<EOF
[Unit]
Description=Karmic Gochara MCP Server
After=network.target

[Service]
Type=simple
User=$USER
WorkingDirectory=/home/$USER/karmic-mcp
ExecStart=/home/$USER/karmic-mcp/venv/bin/uvicorn server:app --host 0.0.0.0 --port 8000
Restart=on-failure
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
EOF

# 6. Enable + start
sudo systemctl daemon-reload
sudo systemctl enable karmic-mcp
sudo systemctl start karmic-mcp

# 7. Open firewall (run from local machine, not the VM)
gcloud compute firewall-rules create allow-karmic-mcp-8000 \
  --project=karmic-gochara-cloud \
  --direction=INGRESS --action=ALLOW --rules=tcp:8000 \
  --source-ranges=0.0.0.0/0 --target-tags=http-server

gcloud compute instances add-tags dev-vm \
  --tags=http-server --zone=europe-west9-a

Useful maintenance commands

# Status
sudo systemctl status karmic-mcp

# Live logs
sudo journalctl -u karmic-mcp -f

# Restart after code update
cd ~/karmic-mcp && git pull && sudo systemctl restart karmic-mcp

📱 Edge Gallery Integration

To register this server with Google AI Edge Gallery:

Open Edge Gallery on your Pixel device
Go to Settings → MCP Servers
Tap Add custom server
Enter:
- Server URL: http://34.163.125.49:8000
- Schema URL: http://34.163.125.49:8000/mcp/discovery
Save and test by asking Gemma:
"Using the Karmic Gochara MCP server, give me today's planetary transits for someone born on 1990-05-15 at 14:30."

The 3 MCP tools will become available to Gemma automatically via schema discovery.

📁 Project Structure

karmic-mcp/
├── server.py              # FastAPI app + MCP endpoints
├── requirements.txt       # Python dependencies
├── test_client.sh         # Local validation script
├── .gitignore             # Excludes venv/, __pycache__/, etc.
├── README.md              # This file
└── README.fr.md           # Version française

🌍 Endpoints Reference

Endpoint	Method	Description	Response time
`/health`	GET	Service health check	<10 ms
`/mcp/discovery`	GET	MCP schema for client auto-config	<50 ms
`/transits/today?dob=YYYY-MM-DD`	GET	Planetary transits for a DOB	<500 ms
`/doctrine/reading?dob=...&birth_time=...`	POST	Synthetic doctrine reading	<2 s

🧠 Built with Gemma-4-E4B-it (local AI case study)

This entire codebase — FastAPI server, Pydantic models, mock client, deployment scripts, and this README — was written end-to-end by Gemma-4-E4B-it, a 4-bit quantized 4B-parameter LLM running locally on the developer's Mac Mini M4 (16 GB RAM).

What the model did

Step	Task	Tool used	Result
1	Generated `server.py` (FastAPI + 3 MCP endpoints)	oMLX inference	183 lines, type-hinted
2	Wrote `requirements.txt` with pinned deps	oMLX inference	Installed cleanly on Python 3.12
3	Authored bilingual README (EN + FR)	oMLX inference	2,500+ words
4	Diagnosed & fixed `pydantic-core` build failure	oMLX + terminal	Switched to Python 3.12 venv
5	Wrote `test_client.sh` validation script	oMLX inference	3/3 tests pass
6	Designed the GCP deployment plan	oMLX reasoning	Systemd service + firewall rules
7	SSH'd into the VM, installed deps, deployed	Hermes Agent delegation	Service live at `http://34.163.125.49:8000`

Why this matters

No cloud LLM was used. Zero OpenAI, zero Anthropic, zero Google API calls during development.
No copy-paste from StackOverflow. Every line was generated by a 4 GB-quantized local model.
The model handled the full stack: Python, FastAPI, Pydantic, systemd, GCP firewall rules, GitHub SSH auth, debugging build failures, and writing deployment docs.
It's a working proof of concept that small local models can ship production services — not just chat demos.

Hardware & software stack

┌──────────────────────────────────────────────────┐
│  Hardware:  Mac Mini M4 · 16 GB unified RAM      │
│  Model:     unsloth/gemma-4-E4B-it-UD-MLX-4bit   │
│  Runtime:   oMLX (local LLM server on :8888)     │
│  Context:   131 K tokens                         │
│  Orchestr.: Hermes Agent (Nous Research)         │
│  Profile:   dev (terminal + cron enabled)        │
└──────────────────────────────────────────────────┘

🤝 Contributing

Pull requests welcome. For major changes, open an issue first to discuss what you'd like to change.

📄 License

MIT

✨ Acknowledgments

Swiss Ephemeris for the astronomical calculation engine
Google AI Edge Gallery for the on-device LLM runtime
Model Context Protocol for the standard MCP spec

Built with ❤️ by Jero · @siderealAstro13 · Karmic Gochara Project

🤖 Code generated with Gemma-4-E4B-it running locally via oMLX on a Mac Mini M4 (16GB RAM), orchestrated by Hermes Agent. 100% local, 0 cloud calls during development.

This server cannot be deployed

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

Maintenance

ActivitySlowing

ResponsivenessSyncing

Resources

GitHub Repository

Need Help?

Related Servers

Related MCP Connectors

Celestium: Cosmic Compass A
io.github.nacrissi
Real astrology for AI agents: cosmic weather, synastry, timing, astrocartography, and divination.
Entertainment & Media
12
Astrology Forecast MCP Server by RoxyAPI A
com.roxyapi
Astrology transit forecasts, timelines and significant-date feeds for AI agents.
Entertainment & Media
52
Enigmata Flow MCP
io.github.enigm-io-sys
Аccess to personalized Enigmata astrological forecasts (day/week/month/thematic) for AI assistants
Entertainment & Media
2
Western Astrology MCP Server by RoxyAPI A
com.roxyapi
Western natal charts, horoscopes, transits and synastry for AI agents, verified vs NASA JPL.
Entertainment & Media
393

Related MCP Servers

Precision astronomical
Research & Data Location Services
scottchronicity
A
license
Not graded
quality
C
maintenance
A self-contained MCP server that gives AI agents the ability to calculate high-precision astronomical data. It provides tropical zodiac coordinates, planetary speeds, retrograde detection, and house cusps using the trusted Swiss Ephemeris engine. 100%
Updated 6 months ago (2026-03-27 02:25 UTC)
4
AGPL 3.0
Retrograde MCP
Weather Services
Griboedow
A
license
A
quality
C
maintenance
A Model Context Protocol server that provides real astronomical data (planetary positions, lunar phases, space weather) with astrological interpretations to help users make decisions about deployments, incident analysis, and scheduling.
Updated 6 months ago (2026-04-03 20:14 UTC)
9
1
Creative Commons Zero v1.0 Universal
Astro MCP Server
Research & Data
aryaminus
F
license
Not graded
quality
C
maintenance
Multi-tradition astrology engine that computes real birth charts, transits, and synastry for AI agents via MCP tools.
Updated 4 months ago (2026-06-08 02:54 UTC)
8
-
auseklis
Research & Data
igmizo
A
license
A
quality
C
maintenance
Astrology MCP server that computes natal charts, transits, synastry, progressions, returns, eclipses, retrogrades, and moon phases from a real ephemeris, enabling AI agents to provide accurate astrological calculations without hallucination.
Updated 3 months ago (2026-07-10 11:06 UTC)
12
71 npm
1
MIT