first commit

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,38 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="PyPackageRequirementsInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredPackages">
+        <value>
+          <list size="25">
+            <item index="0" class="java.lang.String" itemvalue="motor" />
+            <item index="1" class="java.lang.String" itemvalue="PyJWT" />
+            <item index="2" class="java.lang.String" itemvalue="joblib" />
+            <item index="3" class="java.lang.String" itemvalue="scikit-learn" />
+            <item index="4" class="java.lang.String" itemvalue="python-dotenv" />
+            <item index="5" class="java.lang.String" itemvalue="Jinja2" />
+            <item index="6" class="java.lang.String" itemvalue="fastapi_jwt" />
+            <item index="7" class="java.lang.String" itemvalue="pydantic_mongo" />
+            <item index="8" class="java.lang.String" itemvalue="starlette" />
+            <item index="9" class="java.lang.String" itemvalue="uvicorn" />
+            <item index="10" class="java.lang.String" itemvalue="Markdown" />
+            <item index="11" class="java.lang.String" itemvalue="passlib" />
+            <item index="12" class="java.lang.String" itemvalue="pydantic-settings" />
+            <item index="13" class="java.lang.String" itemvalue="pydantic" />
+            <item index="14" class="java.lang.String" itemvalue="transformers" />
+            <item index="15" class="java.lang.String" itemvalue="triton" />
+            <item index="16" class="java.lang.String" itemvalue="pymongo" />
+            <item index="17" class="java.lang.String" itemvalue="langchain_core" />
+            <item index="18" class="java.lang.String" itemvalue="python-multipart" />
+            <item index="19" class="java.lang.String" itemvalue="bcrypt" />
+            <item index="20" class="java.lang.String" itemvalue="fastapi" />
+            <item index="21" class="java.lang.String" itemvalue="sentence_transformers" />
+            <item index="22" class="java.lang.String" itemvalue="contextvars" />
+            <item index="23" class="java.lang.String" itemvalue="beanie" />
+            <item index="24" class="java.lang.String" itemvalue="openpyxl" />
+          </list>
+        </value>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="pyfapi_update" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="pyfapi_update" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/query_mcp_server.iml" filepath="$PROJECT_DIR$/.idea/query_mcp_server.iml" />
+    </modules>
+  </component>
+</project>

.idea/query_mcp_server.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

postgre_mcp_client.py

@@ -0,0 +1,125 @@
+import asyncio
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+from langchain_mcp_adapters.tools import load_mcp_tools
+from langgraph.prebuilt import create_react_agent
+from langchain.chat_models import init_chat_model
+from pprint import pprint
+import logging
+
+llm = init_chat_model(model="gemini-2.0-flash-lite", model_provider="google_genai",api_key ="AIzaSyAuxYmci0DVU5l5L_YcxLlxHzR5MLn70js")
+
+server_params = StdioServerParameters(
+    command="python",
+    # buraya full path konulmalı
+    args=[r"C:\Users\yukcus\Desktop\MCPTest\postgre_mcp_server.py"],
+)
+
+table_summary = """
+The users table stores information about the individuals who use the application. Each user is assigned a unique, auto-incrementing id that serves as the primary key. The username field holds the user's chosen display name and cannot be null, while the email field stores the user’s unique email address, also required and constrained to be unique to avoid duplicates. To track when a user was added to the system, the created_at column records the timestamp of their creation, with a default value set to the current time.
+
+The posts table represents content created by users, such as blog posts or messages. Like the users table, each entry has a unique, auto-incrementing id as the primary key. The user_id field links each post to its author by referencing the id field in the users table, establishing a one-to-many relationship between users and posts. The title column holds a brief summary or headline of the post, while the content field contains the full text. A created_at timestamp is also included to record when each post was created, with a default value of the current time.
+"""
+prompt_temp = """You are an expert in generating SQL queries who has access to a PostgreSQL database through FastMCP tools. These tools allow you to perform operations such as listing tables, retrieving schema information, and executing SQL queries. You do not have prior memory, so if information is needed (e.g., table or column names), use the tools to retrieve it.
+Your job is to carefully analyze the user’s request and:
+1. Select the most appropriate tool(s) based on their descriptions.
+2. If necessary, generate valid and safe SQL queries (only use SELECT queries). If you generate a SQL query, exacute it.
+3. Chain tools when required — for example, list tables → get schema → create query.
+4. Always aim to fulfill the user’s intent while being cautious and accurate.
+
+You must:
+- Never use destructive SQL operations such as DELETE, DROP, or UPDATE.
+- Always ensure the SQL is correct before using the query tool.
+- Use detailed reasoning to choose which tools to invoke.
+
+Only return the final answer to the user’s request. Do not expose internal tool usage or SQL unless the user explicitly asks.
+Here is the user request:
+can you show me the join of all tables?"""
+
+def parse_mcp_output(output_dict):
+    result = []
+    messages = output_dict.get("messages", [])
+
+    for msg in messages:
+        role_name = msg.__class__.__name__  # Example: HumanMessage, AIMessage, ToolMessage
+        content = getattr(msg, "content", "")
+
+        # AIMessage with tool call
+        if role_name == "AIMessage":
+            function_call = getattr(msg, "additional_kwargs", {}).get("function_call")
+            if function_call:
+                tool_name = function_call.get("name")
+                arguments = function_call.get("arguments")
+
+                # Check if arguments is a JSON string or a dict
+                if isinstance(arguments, str):
+                    import json
+                    try:
+                        arguments_dict = json.loads(arguments)
+                    except json.JSONDecodeError:
+                        arguments_dict = {}
+                else:
+                    arguments_dict = arguments or {}
+
+                # Check for presence of "query" key
+                if "query" in arguments_dict:
+                    print("query detected!!!")
+                    print(f"ai said:{content}")
+
+                    result.append({
+                        "type": "ai_function_call",
+                        "query": arguments_dict["query"]
+                    })
+                else:
+                    print(f"ai said:{content}")
+
+            else:
+                print(f"ai final answer:{content}")
+                result.append({
+                    "type": "ai_final_answer",
+                    "ai_said": content
+                })
+
+        # ToolMessage
+        elif role_name == "ToolMessage":
+            tool_name = getattr(msg, "name", None)
+            print(f"tool response:{content}")
+            result.append({
+                "type": "tool_response",
+                "tool": tool_name,
+                "response": content
+            })
+
+
+    return result
+
+
+
+
+async def main():
+    async with stdio_client(server_params) as (read, write):
+        async with ClientSession(read, write) as session:
+            # Initialize the connection
+            await session.initialize()
+
+            # Get tools
+            tools = await load_mcp_tools(session)
+            for tool in tools:
+                tool.description += f" {table_summary}"
+
+            # Create and run the agent
+            agent = create_react_agent(llm, tools)
+            agent_response = await agent.ainvoke({"messages": prompt_temp})
+
+
+            parsed_steps = parse_mcp_output(agent_response)
+            #pprint(parsed_steps)
+
+
+
+
+
+asyncio.run(main())
+
+# open up a new cmd shell and run awith python mcp_client.py

postgre_mcp_server.py

@@ -0,0 +1,440 @@
+import os
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from typing import Optional, AsyncIterator
+
+import asyncpg
+from mcp.server.fastmcp import FastMCP, Context
+from pydantic import Field
+
+# Constants
+DEFAULT_QUERY_LIMIT = 100
+DEFAULT_SCHEMA = "public"
+
+
+# Define our own PromptMessage class if the MCP one isn't available
+@dataclass
+class PromptMessage:
+    content: str
+    role: Optional[str] = "user"
+
+
+# Database context class
+@dataclass
+class DbContext:
+    pool: asyncpg.Pool
+    schema: str
+
+
+# Database connection lifecycle manager
+@asynccontextmanager
+async def db_lifespan(server: FastMCP) -> AsyncIterator[DbContext]:
+    """Manage database connection lifecycle"""
+    # Initialize DB connection from environment variables
+    dsn = os.environ.get("DSN", "postgresql://postgres:postgres@localhost:5432/postgres")
+    schema = os.environ.get("SCHEMA", DEFAULT_SCHEMA)
+    pool = await asyncpg.create_pool(dsn)
+    try:
+        yield DbContext(pool=pool, schema=schema)
+    finally:
+        # Clean up
+        await pool.close()
+
+
+# Create server with database lifecycle management
+mcp = FastMCP(
+    "SQL Database Server",
+    dependencies=["asyncpg", "pydantic"],
+    lifespan=db_lifespan
+)
+
+
+@mcp.tool(description="tests the database connection and returns the PostgreSQL version or an error message.")
+async def test_connection(ctx: Context) -> str:
+    """Test database connection"""
+    try:
+        pool = ctx.request_context.lifespan_context.pool
+        async with pool.acquire() as conn:
+            version = await conn.fetchval("SELECT version();")
+        return f"Connection successful. PostgreSQL version: {version}"
+    except Exception as e:
+        return f"Connection failed: {str(e)}"
+
+
+@mcp.tool(description="Executes a read-only SQL SELECT query and returns formatted results or an error message.")
+async def execute_query(
+        query: str = Field(description="SQL query to execute (SELECT only)"),
+        limit: Optional[int] = Field(default=DEFAULT_QUERY_LIMIT, description="Maximum number of rows to return"),
+        ctx: Context = None
+) -> str:
+    """Execute a read-only SQL query against the database"""
+    # Validate query - simple check for read-only
+    query = query.strip()
+    if not query.lower().startswith("select"):
+        return "Error: Only SELECT queries are allowed for security reasons."
+
+    try:
+        pool = ctx.request_context.lifespan_context.pool
+        async with pool.acquire() as conn:
+            result = await conn.fetch(query)
+
+            if not result:
+                return "Query executed successfully. No rows returned."
+
+            # Format results
+            columns = [k for k in result[0].keys()]
+            header = " | ".join(columns)
+            separator = "-" * len(header)
+
+            # Format rows with limit
+            rows = [" | ".join(str(val) for val in row.values())
+                    for row in result[:limit if limit else DEFAULT_QUERY_LIMIT]]
+
+            return f"{header}\n{separator}\n" + "\n".join(rows)
+    except asyncpg.exceptions.PostgresError as e:
+        return f"SQL Error: {str(e)}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+# Database helper functions
+async def get_all_tables(pool, schema):
+    """Get all tables from the database"""
+    async with pool.acquire() as conn:
+        result = await conn.fetch("""
+            SELECT c.relname AS table_name
+            FROM pg_class AS c
+            JOIN pg_namespace AS n ON n.oid = c.relnamespace
+            WHERE NOT EXISTS (
+                SELECT 1
+                FROM pg_inherits AS i
+                WHERE i.inhrelid = c.oid
+            )
+            AND c.relkind IN ('r', 'p')
+            AND n.nspname = $1
+            AND c.relname NOT LIKE 'pg_%'
+            ORDER BY c.relname;
+        """, schema)
+
+        return result
+
+
+async def get_table_schema_info(pool, schema, table_name):
+    """Get schema information for a specific table"""
+    async with pool.acquire() as conn:
+        columns = await conn.fetch("""
+            SELECT
+                column_name,
+                data_type,
+                is_nullable,
+                column_default,
+                character_maximum_length
+            FROM information_schema.columns
+            WHERE table_schema = $1
+            AND table_name = $2
+            ORDER BY ordinal_position;
+        """, schema, table_name)
+
+        return columns
+
+
+def format_table_schema(table_name, columns):
+    """Format table schema into readable text"""
+    if not columns:
+        return f"Table '{table_name}' not found."
+
+    result = [f"Table: {table_name}", "Columns:"]
+    for col in columns:
+        nullable = "NULL" if col['is_nullable'] == 'YES' else "NOT NULL"
+        length = f"({col['character_maximum_length']})" if col['character_maximum_length'] else ""
+        default = f" DEFAULT {col['column_default']}" if col['column_default'] else ""
+        result.append(f"- {col['column_name']} ({col['data_type']}{length}) {nullable}{default}")
+
+    return "\n".join(result)
+
+
+@mcp.tool(description="Lists all table names in the configured database schema.")
+async def list_tables() -> str:
+    """List all tables in the database"""
+    try:
+        async with db_lifespan(mcp) as db_ctx:
+            result = await get_all_tables(db_ctx.pool, db_ctx.schema)
+
+            if not result:
+                return f"No tables found in the {db_ctx.schema} schema."
+
+            return "\n".join(row['table_name'] for row in result)
+    except asyncpg.exceptions.PostgresError as e:
+        return f"SQL Error: {str(e)}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+@mcp.tool(description="Retrieves and formats the schema details of a specific table in the database.")
+async def get_table_schema(table_name: str) -> str:
+    """Get schema information for a specific table"""
+    try:
+        schema = os.environ.get("SCHEMA", DEFAULT_SCHEMA)
+
+        async with db_lifespan(mcp) as db_ctx:
+            columns = await get_table_schema_info(db_ctx.pool, schema, table_name)
+
+            if not columns:
+                return f"Table '{table_name}' not found in {schema} schema."
+
+            return format_table_schema(table_name, columns)
+    except asyncpg.exceptions.PostgresError as e:
+        return f"SQL Error: {str(e)}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+@mcp.tool(description="Retrieves foreign key relationships for a specified table.")
+def get_foreign_keys(table_name: str) -> str:
+    """Get foreign key information for a table.
+
+    Args:
+        table_name: The name of the table to get foreign keys from
+        schema: The schema name (defaults to 'public')
+    """
+    schema = os.environ.get("SCHEMA", DEFAULT_SCHEMA)
+
+    sql = """
+    SELECT 
+        tc.constraint_name,
+        kcu.column_name as fk_column,
+        ccu.table_schema as referenced_schema,
+        ccu.table_name as referenced_table,
+        ccu.column_name as referenced_column
+    FROM information_schema.table_constraints tc
+    JOIN information_schema.key_column_usage kcu
+        ON tc.constraint_name = kcu.constraint_name
+        AND tc.table_schema = kcu.table_schema
+    JOIN information_schema.referential_constraints rc
+        ON tc.constraint_name = rc.constraint_name
+    JOIN information_schema.constraint_column_usage ccu
+        ON rc.unique_constraint_name = ccu.constraint_name
+    WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_schema = %s
+        AND tc.table_name = %s
+    ORDER BY tc.constraint_name, kcu.ordinal_position
+    """
+    return execute_query(sql)
+
+@mcp.tool(description="Fetches and formats the schema details for all tables in the configured database schema.")
+async def get_all_schemas() -> str:
+    """Get schema information for all tables in the database"""
+    try:
+        schema = os.environ.get("SCHEMA", DEFAULT_SCHEMA)
+
+        async with db_lifespan(mcp) as db_ctx:
+            tables = await get_all_tables(db_ctx.pool, db_ctx.schema)
+
+            if not tables:
+                return f"No tables found in the {db_ctx.schema} schema."
+
+            all_schemas = []
+            for table in tables:
+                table_name = table['table_name']
+                columns = await get_table_schema_info(db_ctx.pool, schema, table_name)
+                table_schema = format_table_schema(table_name, columns)
+                all_schemas.append(table_schema)
+                all_schemas.append("")  # Add empty line between tables
+
+            return "\n".join(all_schemas)
+    except asyncpg.exceptions.PostgresError as e:
+        return f"SQL Error: {str(e)}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+
+@mcp.prompt(description="Generates a prompt message to help craft a best-practice SELECT query for a given table.")
+async def generate_select_query(table_name: str) -> list[PromptMessage]:
+    """Generate a SELECT query with best practices for a table"""
+    try:
+        async with db_lifespan(mcp) as db_ctx:
+            pool = db_ctx.pool
+            async with pool.acquire() as conn:
+                columns = await conn.fetch("""
+                    SELECT column_name, data_type
+                    FROM information_schema.columns 
+                    WHERE table_schema = $1 AND table_name = $2
+                    ORDER BY ordinal_position
+                """, db_ctx.schema, table_name)
+
+            if not columns:
+                return [PromptMessage(f"Table '{table_name}' not found in schema '{db_ctx.schema}'.")]
+
+            columns_text = "\n".join([f"- {col['column_name']} ({col['data_type']})" for col in columns])
+
+            return [
+                PromptMessage(
+                    f"""Please help me write a well-structured, efficient SELECT query for the '{table_name}' table.
+
+                    Table Schema:
+                    {columns_text}
+                    
+                    PostgreSQL SQL Best Practices:
+                    - Use explicit column names instead of * when possible
+                    - Include LIMIT clauses to restrict result sets
+                    - Consider adding WHERE clauses to filter results
+                    - Use appropriate indexing considerations
+                    - Format SQL with proper indentation and line breaks
+                    
+                    Create a basic SELECT query following these best practices:"""
+                                    )
+                                ]
+    except Exception as e:
+        return [PromptMessage(f"Error generating select query: {str(e)}")]
+
+
+@mcp.prompt(description="Generates a prompt message to assist in writing analytical queries for a given table.")
+async def generate_analytical_query(table_name: str) -> list[PromptMessage]:
+    """Generate analytical queries for a table"""
+    try:
+        async with db_lifespan(mcp) as db_ctx:
+            pool = db_ctx.pool
+            async with pool.acquire() as conn:
+                columns = await conn.fetch("""
+                    SELECT column_name, data_type
+                    FROM information_schema.columns 
+                    WHERE table_schema = $1 AND table_name = $2
+                    ORDER BY ordinal_position
+                """, db_ctx.schema, table_name)
+
+            if not columns:
+                return [PromptMessage(f"Table '{table_name}' not found in schema '{db_ctx.schema}'.")]
+
+            columns_text = "\n".join([f"- {col['column_name']} ({col['data_type']})" for col in columns])
+
+            return [
+                PromptMessage(
+                    f"""Please help me create analytical queries for the '{table_name}' table.
+
+                    Table Schema:
+                    {columns_text}
+                    
+                    PostgreSQL SQL Best Practices:
+                    - Use aggregation functions (COUNT, SUM, AVG, MIN, MAX) appropriately
+                    - Group data using GROUP BY for meaningful aggregations
+                    - Filter groups with HAVING clauses when needed
+                    - Consider using window functions for advanced analytics
+                    - Format SQL with proper indentation and line breaks
+                    
+                    Create a set of analytical queries for this table:"""
+                                    )
+                                ]
+    except Exception as e:
+        return [PromptMessage(f"Error generating analytical query: {str(e)}")]
+
+
+
+
+
+@mcp.tool(description="Identifies both explicit and implied foreign key relationships for a given table using schema analysis and naming patterns.")
+def find_relationships(table_name: str, schema: str = 'public') -> str:
+    """Find both explicit and implied relationships for a table.
+
+    Args:
+        table_name: The name of the table to analyze relationships for
+        schema: The schema name (defaults to 'public')
+    """
+    try:
+        # First get explicit foreign key relationships
+        fk_sql = """
+        SELECT 
+            kcu.column_name,
+            ccu.table_name as foreign_table,
+            ccu.column_name as foreign_column,
+            'Explicit FK' as relationship_type,
+            1 as confidence_level
+        FROM information_schema.table_constraints tc
+        JOIN information_schema.key_column_usage kcu 
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+        JOIN information_schema.constraint_column_usage ccu
+            ON ccu.constraint_name = tc.constraint_name
+            AND ccu.table_schema = tc.table_schema
+        WHERE tc.constraint_type = 'FOREIGN KEY'
+            AND tc.table_schema = %s
+            AND tc.table_name = %s
+        """
+
+        # Then look for implied relationships based on common patterns
+        implied_sql = """
+        WITH source_columns AS (
+            -- Get all ID-like columns from our table
+            SELECT column_name, data_type
+            FROM information_schema.columns
+            WHERE table_schema = %s 
+            AND table_name = %s
+            AND (
+                column_name LIKE '%%id' 
+                OR column_name LIKE '%%_id'
+                OR column_name LIKE '%%_fk'
+            )
+        ),
+        potential_references AS (
+            -- Find tables that might be referenced by our ID columns
+            SELECT DISTINCT
+                sc.column_name as source_column,
+                sc.data_type as source_type,
+                t.table_name as target_table,
+                c.column_name as target_column,
+                c.data_type as target_type,
+                CASE
+                    -- Highest confidence: column matches table_id pattern and types match
+                    WHEN sc.column_name = t.table_name || '_id' 
+                        AND sc.data_type = c.data_type THEN 2
+                    -- High confidence: column ends with _id and types match
+                    WHEN sc.column_name LIKE '%%_id' 
+                        AND sc.data_type = c.data_type THEN 3
+                    -- Medium confidence: column contains table name and types match
+                    WHEN sc.column_name LIKE '%%' || t.table_name || '%%'
+                        AND sc.data_type = c.data_type THEN 4
+                    -- Lower confidence: column ends with id and types match
+                    WHEN sc.column_name LIKE '%%id'
+                        AND sc.data_type = c.data_type THEN 5
+                END as confidence_level
+            FROM source_columns sc
+            CROSS JOIN information_schema.tables t
+            JOIN information_schema.columns c 
+                ON c.table_schema = t.table_schema 
+                AND c.table_name = t.table_name
+                AND (c.column_name = 'id' OR c.column_name = sc.column_name)
+            WHERE t.table_schema = %s
+                AND t.table_name != %s  -- Exclude self-references
+        )
+        SELECT 
+            source_column as column_name,
+            target_table as foreign_table,
+            target_column as foreign_column,
+            CASE 
+                WHEN confidence_level = 2 THEN 'Strong implied relationship (exact match)'
+                WHEN confidence_level = 3 THEN 'Strong implied relationship (_id pattern)'
+                WHEN confidence_level = 4 THEN 'Likely implied relationship (name match)'
+                ELSE 'Possible implied relationship'
+            END as relationship_type,
+            confidence_level
+        FROM potential_references
+        WHERE confidence_level IS NOT NULL
+        ORDER BY confidence_level, source_column;
+        """
+
+        # Execute both queries and combine results
+        fk_results = execute_query(fk_sql)
+        implied_results = execute_query(implied_sql)
+
+        # If both queries returned "No results found", return that
+        if fk_results == "No results found" and implied_results == "No results found":
+            return "No relationships found for this table"
+
+        # Otherwise, return both sets of results
+        return f"Explicit Foreign Keys:\n{fk_results}\n\nImplied Relationships:\n{implied_results}"
+
+    except Exception as e:
+        return f"Error finding relationships: {str(e)}"
+
+
+if __name__ == "__main__":
+    mcp.run()