How do I use Karmic Gochara MCP Server?

1. Click on "Install 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 Related Servers Score Discussions

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":"..."}}

🎯 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 installed

license - permissive license

quality - not tested

maintenance

How are these scores calculated?

Maintenance

–Maintainers

–Response time

–Release cycle

–Releases (12mo)

Commit activity

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Latest Blog Posts

Lightport: Open-Sourcing Glama's AI Gateway
By punkpeye on April 27, 2026.
open source
OpenAI
Tool Definition Quality Score (TDQS)
By punkpeye on April 3, 2026.
mcp
The Hackers Who Tracked My Sleep Cycle
By punkpeye on March 26, 2026.
security

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/tripesinn/karmic-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server