yazio-mcp 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Artur Kornakov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,98 @@
+# Yazio MCP Server <img src="https://assets.yazio.com/frontend/images/yazio-logo.svg" alt="Yazio Logo" width="60" height="60" />
+
+> [!IMPORTANT]
+> This is **not an official MCP server** and Yazio does **not provide an official API**.
+> This server uses an [unofficial reverse-engineered API](https://github.com/juriadams/yazio) and may stop working at any time.
+
+An MCP (Model Context Protocol) server that connects Claude/Cursor to your Yazio nutrition data. Track your diet, search food products, and manage your nutrition goals directly from your AI assistant.
+
+**Available on NPM**: `npx yazio-mcp`
+
+## ✨ Features
+
+- 🔐 **Authentication** - Connect with your Yazio account
+- 📊 **Nutrition Analysis** - Get comprehensive diet data and insights
+- 🍎 **Food Tracking** - Search, add, and manage food entries
+- 🏃‍♂️ **Fitness Data** - Track exercises and water intake
+- ⚖️ **Weight Monitoring** - View weight history and trends
+- 🎯 **Goal Management** - Access and manage nutrition goals
+- 🔍 **Product Search** - Search Yazio's extensive food database
+
+## 🚀 Quick Start
+
+Add to your MCP client configuration:
+
+**Claude Desktop**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+
+**Cursor**: Your Cursor MCP configuration file
+
+```json
+{
+  "mcpServers": {
+    "yazio-mcp": {
+      "command": "npx yazio-mcp",
+      "env": {
+        "YAZIO_USERNAME": "your-email@example.com",
+        "YAZIO_PASSWORD": "your-password"
+      }
+    }
+  }
+}
+```
+
+## 💡 Use Cases
+
+### 📈 Analyze Your Nutrition Trends
+> *"Get my nutrition data for the last week and analyze my eating patterns"*
+
+Claude can retrieve your daily summaries, identify trends, and provide insights about your eating habits, macro distribution, and areas for improvement.
+
+### 🔍 Search Food Products
+> *"Search for 'chicken breast' in the Yazio database"*
+
+Find detailed nutritional information for any food product, including calories, macros, vitamins, and minerals.
+
+### 📝 Add Forgotten Meals
+> *"Add 200g of grilled salmon for yesterday's dinner"*
+
+Easily log meals you forgot to track in the Yazio app directly from Claude or Cursor.
+
+## 🛠️ Available Tools
+
+| Tool | Description | Key Parameters |
+|------|-------------|----------------|
+| `get_user_daily_summary` | Get daily nutrition summary | `date` |
+| `get_user_consumed_items` | Get food entries for a date | `date` |
+| `get_user_weight` | Get weight data | - |
+| `get_user_exercises` | Get exercise data | `date` |
+| `get_user_water_intake` | Get water intake | `date` |
+| `get_user_goals` | Get nutrition goals | - |
+| `get_user_settings` | Get user preferences | - |
+| `search_products` | Search food database | `query` |
+| `get_product` | Get detailed product info | `id` |
+| `add_user_consumed_item` | Add food to your log | `productId`, `amount`, `date`, `mealType` |
+| `remove_user_consumed_item` | Remove food from log | `itemId` |
+
+## Test Connection
+
+```bash
+YAZIO_USERNAME=your_email YAZIO_PASSWORD=your_password npx yazio-mcp
+```
+
+## ⚠️ Important Disclaimers
+
+- **Unofficial API**: This uses a [reverse-engineered API](https://github.com/juriadams/yazio) that may break
+- **Credentials**: Your Yazio credentials are only used for auth on Yazio servers
+- **Use at Your Own Risk**: API changes could affect functionality
+
+## 📋 Requirements
+
+- Node.js 18+ (for npx)
+- Valid Yazio account
+- MCP-compatible client (Claude Desktop, Cursor, etc.)
+
+---
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) file for details.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,495 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
+import { Yazio } from 'yazio';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { GetFoodEntriesInputSchema, GetDailySummaryInputSchema, GetUserInfoInputSchema, GetUserWeightInputSchema, GetWaterIntakeInputSchema, SearchProductsInputSchema, GetProductInputSchema, GetUserExercisesInputSchema, GetUserSettingsInputSchema, GetUserSuggestedProductsInputSchema, AddConsumedItemInputSchema, RemoveConsumedItemInputSchema, GetDietaryPreferencesInputSchema, GetUserGoalsInputSchema } from './schemas.js';
+class YazioMcpServer {
+    server;
+    yazioClient = null;
+    constructor() {
+        this.server = new Server({
+            name: 'yazio-mcp',
+            version: '1.0.0',
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.setupToolHandlers();
+        this.setupErrorHandling();
+        this.initializeClient();
+    }
+    async initializeClient() {
+        const username = process.env.YAZIO_USERNAME;
+        const password = process.env.YAZIO_PASSWORD;
+        if (!username || !password) {
+            console.error('❌ YAZIO_USERNAME and YAZIO_PASSWORD environment variables are required');
+            console.error('💡 Please set these environment variables with your Yazio account credentials');
+            process.exit(1);
+        }
+        try {
+            this.yazioClient = new Yazio({
+                credentials: {
+                    username,
+                    password
+                }
+            });
+            // Test the connection
+            await this.yazioClient.user.get();
+            console.error('✅ Successfully authenticated with Yazio using environment variables');
+        }
+        catch (error) {
+            console.error('❌ Failed to authenticate with Yazio:', error.message);
+            console.error('💡 Please check your YAZIO_USERNAME and YAZIO_PASSWORD environment variables');
+            process.exit(1);
+        }
+    }
+    setupErrorHandling() {
+        this.server.onerror = (error) => console.error('[MCP Error]', error);
+        process.on('SIGINT', async () => {
+            await this.server.close();
+            process.exit(0);
+        });
+    }
+    setupToolHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: [
+                {
+                    name: 'get_product',
+                    description: 'Get detailed information about a specific product by ID',
+                    inputSchema: zodToJsonSchema(GetProductInputSchema),
+                    annotations: {
+                        readOnlyHint: true,
+                        idempotentHint: true,
+                        openWorldHint: true
+                    }
+                },
+                {
+                    name: 'get_user',
+                    description: 'Get Yazio user profile information',
+                    inputSchema: zodToJsonSchema(GetUserInfoInputSchema),
+                    annotations: {
+                        readOnlyHint: true,
+                        idempotentHint: true
+                    }
+                },
+                {
+                    name: 'get_user_consumed_items',
+                    description: 'Get food entries for a specific date',
+                    inputSchema: zodToJsonSchema(GetFoodEntriesInputSchema),
+                    annotations: {
+                        readOnlyHint: true,
+                        idempotentHint: true
+                    }
+                },
+                {
+                    name: 'get_user_dietary_preferences',
+                    description: 'Get user dietary preferences and restrictions',
+                    inputSchema: zodToJsonSchema(GetDietaryPreferencesInputSchema),
+                    annotations: {
+                        readOnlyHint: true,
+                        idempotentHint: true
+                    }
+                },
+                {
+                    name: 'get_user_exercises',
+                    description: 'Get user exercise data for a date or date range',
+                    inputSchema: zodToJsonSchema(GetUserExercisesInputSchema),
+                    annotations: {
+                        readOnlyHint: true,
+                        idempotentHint: true
+                    }
+                },
+                {
+                    name: 'get_user_goals',
+                    description: 'Get user nutrition and fitness goals',
+                    inputSchema: zodToJsonSchema(GetUserGoalsInputSchema),
+                    annotations: {
+                        readOnlyHint: true,
+                        idempotentHint: true
+                    }
+                },
+                {
+                    name: 'get_user_settings',
+                    description: 'Get user settings and preferences',
+                    inputSchema: zodToJsonSchema(GetUserSettingsInputSchema),
+                    annotations: {
+                        readOnlyHint: true,
+                        idempotentHint: true
+                    }
+                },
+                {
+                    name: 'get_user_suggested_products',
+                    description: 'Get product suggestions for the user',
+                    inputSchema: zodToJsonSchema(GetUserSuggestedProductsInputSchema),
+                    annotations: {
+                        readOnlyHint: true,
+                        idempotentHint: true,
+                        openWorldHint: true
+                    }
+                },
+                {
+                    name: 'get_user_water_intake',
+                    description: 'Get water intake data for a specific date',
+                    inputSchema: zodToJsonSchema(GetWaterIntakeInputSchema),
+                    annotations: {
+                        readOnlyHint: true,
+                        idempotentHint: true
+                    }
+                },
+                {
+                    name: 'get_user_weight',
+                    description: 'Get user weight data',
+                    inputSchema: zodToJsonSchema(GetUserWeightInputSchema),
+                    annotations: {
+                        readOnlyHint: true,
+                        idempotentHint: true
+                    }
+                },
+                {
+                    name: 'search_products',
+                    description: 'Search for food products in Yazio database',
+                    inputSchema: zodToJsonSchema(SearchProductsInputSchema),
+                    annotations: {
+                        readOnlyHint: true,
+                        idempotentHint: true,
+                        openWorldHint: true
+                    }
+                },
+                {
+                    name: 'get_user_daily_summary',
+                    description: 'Get daily nutrition summary for a specific date',
+                    inputSchema: zodToJsonSchema(GetDailySummaryInputSchema),
+                    annotations: {
+                        readOnlyHint: true,
+                        idempotentHint: true
+                    }
+                },
+                {
+                    name: 'add_user_consumed_item',
+                    description: 'Add a food item to user consumption log',
+                    inputSchema: zodToJsonSchema(AddConsumedItemInputSchema),
+                    annotations: {
+                        readOnlyHint: false,
+                        idempotentHint: false
+                    }
+                },
+                {
+                    name: 'remove_user_consumed_item',
+                    description: 'Remove a food item from user consumption log',
+                    inputSchema: zodToJsonSchema(RemoveConsumedItemInputSchema),
+                    annotations: {
+                        readOnlyHint: false,
+                        destructiveHint: true,
+                        idempotentHint: true
+                    }
+                },
+            ],
+        }));
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                switch (name) {
+                    case 'get_product':
+                        return await this.getProduct(GetProductInputSchema.parse(args));
+                    case 'get_user':
+                        return await this.getUser();
+                    case 'get_user_consumed_items':
+                        return await this.getUserConsumedItems(GetFoodEntriesInputSchema.parse(args));
+                    case 'get_user_dietary_preferences':
+                        return await this.getUserDietaryPreferences();
+                    case 'get_user_exercises':
+                        return await this.getUserExercises(GetUserExercisesInputSchema.parse(args));
+                    case 'get_user_goals':
+                        return await this.getUserGoals();
+                    case 'get_user_settings':
+                        return await this.getUserSettings();
+                    case 'get_user_suggested_products':
+                        return await this.getUserSuggestedProducts(GetUserSuggestedProductsInputSchema.parse(args));
+                    case 'get_user_water_intake':
+                        return await this.getUserWaterIntake(GetWaterIntakeInputSchema.parse(args));
+                    case 'get_user_weight':
+                        return await this.getUserWeight();
+                    case 'search_products':
+                        return await this.searchProducts(SearchProductsInputSchema.parse(args));
+                    case 'get_user_daily_summary':
+                        return await this.getUserDailySummary(GetDailySummaryInputSchema.parse(args));
+                    case 'add_user_consumed_item':
+                        return await this.addUserConsumedItem(AddConsumedItemInputSchema.parse(args));
+                    case 'remove_user_consumed_item':
+                        return await this.removeUserConsumedItem(RemoveConsumedItemInputSchema.parse(args));
+                    default:
+                        throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                throw new McpError(ErrorCode.InternalError, errorMessage);
+            }
+        });
+    }
+    async ensureAuthenticated() {
+        if (!this.yazioClient) {
+            throw new Error('Yazio client not initialized. Check environment variables.');
+        }
+        return this.yazioClient;
+    }
+    async getUserConsumedItems(args) {
+        const client = await this.ensureAuthenticated();
+        try {
+            const foodEntries = await client.user.getConsumedItems({ date: new Date(args.date) });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Food entries for ${args.date}:\n\n${JSON.stringify(foodEntries, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to get food entries: ${error}`);
+        }
+    }
+    async getUser() {
+        const client = await this.ensureAuthenticated();
+        try {
+            const userInfo = await client.user.get();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `User info:\n\n${JSON.stringify(userInfo, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to get user info: ${error}`);
+        }
+    }
+    async getUserDailySummary(args) {
+        const client = await this.ensureAuthenticated();
+        try {
+            const summary = await client.user.getDailySummary({ date: new Date(args.date) });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Daily summary for ${args.date}:\n\n${JSON.stringify(summary, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to get daily summary: ${error}`);
+        }
+    }
+    async getUserWeight() {
+        const client = await this.ensureAuthenticated();
+        try {
+            // Yazio getWeight doesn't support date ranges, just single date
+            const weight = await client.user.getWeight();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `User weight data:\n\n${JSON.stringify(weight, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to get user weight: ${error}`);
+        }
+    }
+    async getUserWaterIntake(args) {
+        const client = await this.ensureAuthenticated();
+        try {
+            const waterIntake = await client.user.getWaterIntake({ date: new Date(args.date) });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Water intake for ${args.date}:\n\n${JSON.stringify(waterIntake, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to get water intake: ${error}`);
+        }
+    }
+    async searchProducts(args) {
+        const client = await this.ensureAuthenticated();
+        try {
+            const products = await client.products.search(args);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Search results for "${args.query}":\n\n${JSON.stringify(products, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to search products: ${error}`);
+        }
+    }
+    async getProduct(args) {
+        const client = await this.ensureAuthenticated();
+        try {
+            const product = await client.products.get(args.id);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Product details for ID "${args.id}":\n\n${JSON.stringify(product, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to get product: ${error}`);
+        }
+    }
+    async getUserExercises(args) {
+        const client = await this.ensureAuthenticated();
+        try {
+            const apiOptions = {};
+            if (args.date) {
+                apiOptions.date = args.date;
+            }
+            const exercises = await client.user.getExercises(apiOptions);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `User exercises:\n\n${JSON.stringify(exercises, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to get user exercises: ${error}`);
+        }
+    }
+    async getUserSettings() {
+        const client = await this.ensureAuthenticated();
+        try {
+            const settings = await client.user.getSettings();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `User settings:\n\n${JSON.stringify(settings, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to get user settings: ${error}`);
+        }
+    }
+    async getUserSuggestedProducts(args) {
+        const client = await this.ensureAuthenticated();
+        try {
+            const options = {
+                daytime: 'breakfast',
+                ...args
+            };
+            const suggestions = await client.user.getSuggestedProducts(options);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Product suggestions:\n\n${JSON.stringify(suggestions, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to get product suggestions: ${error}`);
+        }
+    }
+    async addUserConsumedItem(args) {
+        const client = await this.ensureAuthenticated();
+        try {
+            // The Yazio API expects specific parameters, we'll pass them directly
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result = await client.user.addConsumedItem(args);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Successfully added consumed item:\n\n${JSON.stringify(result, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to add consumed item: ${error}`);
+        }
+    }
+    async removeUserConsumedItem(args) {
+        const client = await this.ensureAuthenticated();
+        try {
+            const result = await client.user.removeConsumedItem(args.itemId);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Successfully removed consumed item with ID: ${args.itemId}\n\n${JSON.stringify(result, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to remove consumed item: ${error}`);
+        }
+    }
+    async getUserDietaryPreferences() {
+        const client = await this.ensureAuthenticated();
+        try {
+            const preferences = await client.user.getDietaryPreferences();
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Dietary preferences:\n\n${JSON.stringify(preferences, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to get dietary preferences: ${error}`);
+        }
+    }
+    async getUserGoals() {
+        const client = await this.ensureAuthenticated();
+        try {
+            const goals = await client.user.getGoals({});
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `User goals:\n\n${JSON.stringify(goals, null, 2)}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to get user goals: ${error}`);
+        }
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        console.error('Yazio MCP server running on stdio');
+    }
+}
+const server = new YazioMcpServer();
+server.run().catch(console.error);

package/dist/schemas.d.ts

@@ -0,0 +1,137 @@
+import { z } from 'zod';
+export declare const DaytimeSchema: z.ZodEnum<["breakfast", "lunch", "dinner", "snack"]>;
+export type Daytime = z.infer<typeof DaytimeSchema>;
+export declare const DateStringSchema: z.ZodString;
+export declare const ProductIdSchema: z.ZodString;
+export declare const ItemIdSchema: z.ZodString;
+export declare const QueryStringSchema: z.ZodString;
+export declare const LimitSchema: z.ZodOptional<z.ZodNumber>;
+export declare const DateInputSchema: z.ZodObject<{
+    date: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    date: string;
+}, {
+    date: string;
+}>;
+export declare const OptionalDateInputSchema: z.ZodObject<{
+    date: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    date?: string | undefined;
+}, {
+    date?: string | undefined;
+}>;
+export declare const QueryInputSchema: z.ZodObject<{
+    query: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+}, {
+    query: string;
+}>;
+export declare const OptionalQueryInputSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    query?: string | undefined;
+    limit?: number | undefined;
+}, {
+    query?: string | undefined;
+    limit?: number | undefined;
+}>;
+export declare const EmptyInputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const GetFoodEntriesInputSchema: z.ZodObject<{
+    date: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    date: string;
+}, {
+    date: string;
+}>;
+export declare const GetDailySummaryInputSchema: z.ZodObject<{
+    date: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    date: string;
+}, {
+    date: string;
+}>;
+export declare const GetUserInfoInputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const GetUserWeightInputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const GetWaterIntakeInputSchema: z.ZodObject<{
+    date: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    date: string;
+}, {
+    date: string;
+}>;
+export declare const SearchProductsInputSchema: z.ZodObject<{
+    query: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+}, {
+    query: string;
+}>;
+export declare const GetProductInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+export declare const GetUserExercisesInputSchema: z.ZodObject<{
+    date: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    date?: string | undefined;
+}, {
+    date?: string | undefined;
+}>;
+export declare const GetUserSettingsInputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const GetUserSuggestedProductsInputSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    query?: string | undefined;
+    limit?: number | undefined;
+}, {
+    query?: string | undefined;
+    limit?: number | undefined;
+}>;
+export declare const AddConsumedItemInputSchema: z.ZodObject<{
+    productId: z.ZodOptional<z.ZodString>;
+    amount: z.ZodOptional<z.ZodNumber>;
+    unit: z.ZodOptional<z.ZodString>;
+    date: z.ZodOptional<z.ZodString>;
+    mealType: z.ZodOptional<z.ZodEnum<["breakfast", "lunch", "dinner", "snack"]>>;
+}, "strip", z.ZodTypeAny, {
+    date?: string | undefined;
+    productId?: string | undefined;
+    amount?: number | undefined;
+    unit?: string | undefined;
+    mealType?: "breakfast" | "lunch" | "dinner" | "snack" | undefined;
+}, {
+    date?: string | undefined;
+    productId?: string | undefined;
+    amount?: number | undefined;
+    unit?: string | undefined;
+    mealType?: "breakfast" | "lunch" | "dinner" | "snack" | undefined;
+}>;
+export declare const RemoveConsumedItemInputSchema: z.ZodObject<{
+    itemId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    itemId: string;
+}, {
+    itemId: string;
+}>;
+export declare const GetDietaryPreferencesInputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const GetUserGoalsInputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export type GetFoodEntriesInput = z.infer<typeof GetFoodEntriesInputSchema>;
+export type GetDailySummaryInput = z.infer<typeof GetDailySummaryInputSchema>;
+export type GetUserInfoInput = z.infer<typeof GetUserInfoInputSchema>;
+export type GetUserWeightInput = z.infer<typeof GetUserWeightInputSchema>;
+export type GetWaterIntakeInput = z.infer<typeof GetWaterIntakeInputSchema>;
+export type SearchProductsInput = z.infer<typeof SearchProductsInputSchema>;
+export type GetProductInput = z.infer<typeof GetProductInputSchema>;
+export type GetUserExercisesInput = z.infer<typeof GetUserExercisesInputSchema>;
+export type GetUserSettingsInput = z.infer<typeof GetUserSettingsInputSchema>;
+export type GetUserSuggestedProductsInput = z.infer<typeof GetUserSuggestedProductsInputSchema>;
+export type AddConsumedItemInput = z.infer<typeof AddConsumedItemInputSchema>;
+export type RemoveConsumedItemInput = z.infer<typeof RemoveConsumedItemInputSchema>;
+export type GetDietaryPreferencesInput = z.infer<typeof GetDietaryPreferencesInputSchema>;
+export type GetUserGoalsInput = z.infer<typeof GetUserGoalsInputSchema>;

package/dist/schemas.js

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+export const DaytimeSchema = z.enum(['breakfast', 'lunch', 'dinner', 'snack']);
+export const DateStringSchema = z.string().describe('Date in YYYY-MM-DD format');
+export const ProductIdSchema = z.string().describe('Unique product identifier');
+export const ItemIdSchema = z.string().describe('Unique item identifier');
+export const QueryStringSchema = z.string().describe('Search query string');
+export const LimitSchema = z.number().optional().describe('Maximum number of results to return');
+export const DateInputSchema = z.object({
+    date: DateStringSchema.describe('Date to get data for')
+});
+export const OptionalDateInputSchema = z.object({
+    date: DateStringSchema.optional().describe('Specific date to get data for (optional)')
+});
+export const QueryInputSchema = z.object({
+    query: QueryStringSchema.describe('Search query')
+});
+export const OptionalQueryInputSchema = z.object({
+    query: QueryStringSchema.optional().describe('Search query (optional)'),
+    limit: LimitSchema
+});
+export const EmptyInputSchema = z.object({});
+export const GetFoodEntriesInputSchema = DateInputSchema;
+export const GetDailySummaryInputSchema = DateInputSchema;
+export const GetUserInfoInputSchema = EmptyInputSchema;
+export const GetUserWeightInputSchema = EmptyInputSchema; // Yazio getWeight doesn't accept parameters
+export const GetWaterIntakeInputSchema = DateInputSchema;
+export const SearchProductsInputSchema = QueryInputSchema;
+export const GetProductInputSchema = z.object({
+    id: ProductIdSchema.describe('Product ID to get details for')
+});
+export const GetUserExercisesInputSchema = OptionalDateInputSchema; // Only supports single date, not date ranges
+export const GetUserSettingsInputSchema = EmptyInputSchema;
+export const GetUserSuggestedProductsInputSchema = OptionalQueryInputSchema;
+export const AddConsumedItemInputSchema = z.object({
+    productId: z.string().optional().describe('ID of the product to add'),
+    amount: z.number().optional().describe('Amount of the product consumed'),
+    unit: z.string().optional().describe('Unit of measurement (g, ml, pieces, etc.)'),
+    date: z.string().optional().describe('Date when the food was consumed (defaults to today) in YYYY-MM-DD format'),
+    mealType: DaytimeSchema.optional().describe('Type of meal')
+});
+export const RemoveConsumedItemInputSchema = z.object({
+    itemId: ItemIdSchema.describe('ID of the consumed item to remove')
+});
+export const GetDietaryPreferencesInputSchema = EmptyInputSchema;
+export const GetUserGoalsInputSchema = EmptyInputSchema;

package/dist/types.d.ts

@@ -0,0 +1,266 @@
+export interface YazioProduct {
+    id: string;
+    name: string;
+    is_verified: boolean;
+    is_private: boolean;
+    is_deleted: boolean;
+    has_ean: boolean;
+    category: string;
+    producer: string | null;
+    nutrients: {
+        "energy.energy": number;
+        "mineral.calcium": number;
+        "mineral.chlorine": number;
+        "mineral.copper": number;
+        "mineral.fluorine": number;
+        "mineral.iron": number;
+        "mineral.magnesium": number;
+        "mineral.manganese": number;
+        "mineral.phosphorus": number;
+        "mineral.potassium": number;
+        "mineral.sulfur": number;
+        "mineral.zinc": number;
+        "nutrient.carb": number;
+        "nutrient.dietaryfiber": number;
+        "nutrient.fat": number;
+        "nutrient.protein": number;
+        "nutrient.sugar": number;
+        "vitamin.a": number;
+        "vitamin.b1": number;
+        "vitamin.b12": number;
+        "vitamin.b2": number;
+        "vitamin.b6": number;
+        "vitamin.d": number;
+        "vitamin.e": number;
+    };
+    updated_at: string;
+    servings: {
+        serving: string;
+        amount: number;
+    }[];
+    base_unit: string;
+    eans: string[];
+    language: string;
+    countries: string[];
+}
+export interface YazioProductSearchResult {
+    serving: string;
+    amount: number;
+    name: string;
+    is_verified: boolean;
+    producer: string;
+    nutrients: {
+        "energy.energy": number;
+        "nutrient.carb": number;
+        "nutrient.fat": number;
+        "nutrient.protein": number;
+    };
+    base_unit: string;
+    language: string;
+    countries: string[];
+    score: number;
+    product_id: string;
+    serving_quantity: number;
+}
+export interface YazioUserInfo {
+    sex: "male" | "female" | "other";
+    unit_mass: string;
+    unit_energy: string;
+    unit_serving: string;
+    unit_length: string;
+    start_weight: number;
+    goal: string;
+    diet: {
+        name: string;
+        carb_percentage: number;
+        fat_percentage: number;
+        protein_percentage: number;
+    } | null;
+    email: string;
+    premium_type: string;
+    first_name: string;
+    last_name: string;
+    city: string;
+    country: string;
+    weight_change_per_week: number;
+    body_height: number;
+    date_of_birth: string;
+    registration_date: string;
+    timezone_offset: number;
+    unit_glucose: string;
+    food_database_country: string;
+    profile_image: string;
+    user_token: string;
+    email_confirmation_status: "confirmed" | "unconfirmed";
+    newsletter_opt_in: boolean;
+    login_type: string;
+    siwa_user_id: string | null;
+    uuid: string;
+    reset_date: string | null;
+    activity_degree: string;
+    stripe_customer_id: string | null;
+}
+export interface YazioWeightEntry {
+    value: number | null;
+    date: string;
+    id: string;
+    external_id: string | null;
+    gateway: string | null;
+    source: string | null;
+}
+export interface YazioSuggestedProduct {
+    serving: string | null;
+    amount: number;
+    product_id: string;
+    serving_quantity: number | null;
+}
+export interface YazioDietaryPreferences {
+    restriction: string | null;
+}
+export interface YazioExercise {
+    date: string;
+    id: string;
+    name: string;
+    external_id: string | null;
+    gateway: string | null;
+    source: string | null;
+    note: string | null;
+    energy: number;
+    distance: number;
+    duration: number;
+    steps: number;
+}
+export interface YazioExercises {
+    training: YazioExercise[];
+    custom_training: YazioExercise[];
+}
+export interface YazioGoals {
+    "energy.energy": number;
+    "nutrient.carb": number;
+    "nutrient.fat": number;
+    "nutrient.protein": number;
+    "activity.step": number;
+    "bodyvalue.weight": number;
+    water: number;
+}
+export interface YazioSettings {
+    has_water_tracker: boolean;
+    has_diary_tipps: boolean;
+    has_meal_reminders: boolean;
+    has_usage_reminders: boolean;
+    has_weight_reminders: boolean;
+    has_water_reminders: boolean;
+    consume_activity_calories: boolean;
+    has_feelings: boolean;
+    has_fasting_tracker_reminders: boolean;
+    has_fasting_stage_reminders: boolean;
+}
+export interface YazioWaterIntake {
+    gateway: string | null;
+    source: string | null;
+    water_intake: number;
+}
+export interface YazioDailySummary {
+    steps: number;
+    activity_energy: number;
+    consume_activity_energy: boolean;
+    water_intake: number;
+    goals: YazioGoals;
+    units: {
+        unit_mass: string;
+        unit_energy: string;
+        unit_serving: string;
+        unit_length: string;
+    };
+    meals: {
+        breakfast: {
+            nutrients: {
+                "energy.energy": number;
+                "nutrient.carb": number;
+                "nutrient.fat": number;
+                "nutrient.protein": number;
+            };
+            energy_goal: number;
+        };
+        lunch: {
+            nutrients: {
+                "energy.energy": number;
+                "nutrient.carb": number;
+                "nutrient.fat": number;
+                "nutrient.protein": number;
+            };
+            energy_goal: number;
+        };
+        dinner: {
+            nutrients: {
+                "energy.energy": number;
+                "nutrient.carb": number;
+                "nutrient.fat": number;
+                "nutrient.protein": number;
+            };
+            energy_goal: number;
+        };
+        snack: {
+            nutrients: {
+                "energy.energy": number;
+                "nutrient.carb": number;
+                "nutrient.fat": number;
+                "nutrient.protein": number;
+            };
+            energy_goal: number;
+        };
+    };
+    user: {
+        start_weight?: number;
+        current_weight?: number;
+        goal?: string;
+        sex?: string;
+    };
+    active_fasting_countdown_template_key: string | null;
+}
+export interface YazioConsumedItem {
+    type: string;
+    date: string;
+    serving: string | null;
+    amount: number;
+    id: string;
+    product_id: string;
+    serving_quantity: number | null;
+    daytime: "breakfast" | "lunch" | "dinner" | "snack";
+}
+export interface YazioConsumedItems {
+    products: YazioConsumedItem[];
+    recipe_portions: unknown[];
+    simple_products: unknown[];
+}
+export interface YazioWeightOptions {
+    date?: string | Date;
+}
+export interface YazioExerciseOptions {
+    date?: string | Date;
+}
+export interface YazioSuggestedProductsOptions {
+    daytime: "breakfast" | "lunch" | "dinner" | "snack";
+    date?: string | Date;
+}
+export interface YazioWaterIntakeOptions {
+    date: string | Date;
+}
+export interface YazioDailySummaryOptions {
+    date: string | Date;
+}
+export interface YazioConsumedItemsOptions {
+    date: string | Date;
+}
+export interface YazioAddConsumedItemOptions {
+    date: string | Date;
+    serving: string;
+    amount: number;
+    id: string;
+    product_id: string;
+    serving_quantity: number;
+    daytime: "breakfast" | "lunch" | "dinner" | "snack";
+}
+export interface YazioRemoveConsumedItemOptions {
+    itemId: string;
+}

package/dist/types.js

@@ -0,0 +1,3 @@
+// Type definitions for Yazio API responses
+// These are extracted from the yazio package types
+export {};

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "yazio-mcp",
+  "version": "0.0.1",
+  "description": "MCP server for accessing Yazio user & nutrition data (unofficial)",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "bin": {
+    "yazio-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build",
+    "lint": "eslint src/**/*.ts",
+    "lint:fix": "eslint src/**/*.ts --fix",
+    "format": "prettier --write src/**/*.ts",
+    "type-check": "tsc --noEmit"
+  },
+  "keywords": [
+    "mcp",
+    "yazio",
+    "nutrition",
+    "diet",
+    "model-context-protocol",
+    "health",
+    "fitness"
+  ],
+  "author": "fliptheweb",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/arturkornakov/yazio-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/arturkornakov/yazio-mcp/issues"
+  },
+  "homepage": "https://github.com/arturkornakov/yazio-mcp#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.18.2",
+    "yazio": "^1.0.0",
+    "zod": "^3.22.0",
+    "zod-to-json-schema": "^3.24.6"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.44.1",
+    "@typescript-eslint/parser": "^8.44.1",
+    "eslint": "^9.36.0",
+    "globals": "^16.4.0",
+    "prettier": "^3.6.2",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  }
+}