PyPI - finta-aurora-mcp - Versions diffs - 1.0.0__py3-none-any.whl - Mend

finta-aurora-mcp 1.0.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

finta_aurora_mcp/__init__.py +3 -0
finta_aurora_mcp/auth.py +105 -0
finta_aurora_mcp/fix_org_info.py +44 -0
finta_aurora_mcp/mcp.py +498 -0
finta_aurora_mcp-1.0.0.dist-info/METADATA +216 -0
finta_aurora_mcp-1.0.0.dist-info/RECORD +19 -0
finta_aurora_mcp-1.0.0.dist-info/WHEEL +5 -0
finta_aurora_mcp-1.0.0.dist-info/top_level.txt +2 -0
tools/__init__.py +23 -0
tools/addInvestorToTrackerTool.py +114 -0
tools/contactSupportTool.py +7 -0
tools/editInvestorTool.py +653 -0
tools/getInvestorTool.py +109 -0
tools/imageTool.py +77 -0
tools/pdfScraperTool.py +31 -0
tools/pineconeKnowledgeTool.py +35 -0
tools/pineconeResourceTool.py +27 -0
tools/serpAPITool.py +16 -0
tools/webScraperTool.py +30 -0

finta_aurora_mcp/__init__.py ADDED Viewed

@@ -0,0 +1,3 @@
+"""Finta Aurora MCP - Chat with Aurora AI from Cursor/Claude Desktop."""
+__version__ = "1.0.0"

finta_aurora_mcp/auth.py ADDED Viewed

@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+"""
+Aurora MCP Authentication
+Simple OAuth login - opens browser and stores token.
+"""
+import os
+import sys
+import webbrowser
+import http.server
+import socketserver
+import urllib.parse
+import json
+import requests
+from pathlib import Path
+FINTA_API_URL_STAGING = "https://us-central1-equity-token-stage.cloudfunctions.net"
+FINTA_API_URL_PRODUCTION = "https://us-central1-equity-token.cloudfunctions.net"
+def get_api_url():
+    """Get API URL based on environment."""
+    use_staging = os.getenv("FINTA_STAGING", "true").lower() == "true"
+    return FINTA_API_URL_STAGING if use_staging else FINTA_API_URL_PRODUCTION
+def get_token_path():
+    """Get path to store token."""
+    return Path.home() / ".cursor" / "aurora_token.json"
+def main():
+    print("Aurora MCP Authentication")
+    print("=" * 40)
+    print("Opening browser for login...\n")
+    api_url = get_api_url()
+    auth_url = (
+        f"{api_url}/auroraOAuthAuthorize?"
+        f"response_type=code&"
+        f"client_id=cursor&"
+        f"redirect_uri=http://localhost:8765/callback"
+    )
+    webbrowser.open(auth_url)
+    class CallbackHandler(http.server.SimpleHTTPRequestHandler):
+        def do_GET(self):
+            query = urllib.parse.urlparse(self.path).query
+            params = urllib.parse.parse_qs(query)
+            if 'code' in params:
+                code = params['code'][0]
+                api_url = get_api_url()
+                try:
+                    resp = requests.post(
+                        f"{api_url}/auroraOAuthToken",
+                        json={
+                            "grant_type": "authorization_code",
+                            "code": code,
+                            "redirect_uri": "http://localhost:8765/callback"
+                        },
+                        timeout=10
+                    )
+                    if resp.status_code == 200:
+                        token_data = resp.json()
+                        access_token = token_data.get("access_token")
+                        token_path = get_token_path()
+                        token_path.parent.mkdir(exist_ok=True)
+                        with open(token_path, 'w') as f:
+                            json.dump(token_data, f, indent=2)
+                        self.send_response(200)
+                        self.send_header('Content-type', 'text/html; charset=utf-8')
+                        self.end_headers()
+                        html = """<html><body style="font-family: system-ui; padding: 40px; text-align: center;"><h1>Authentication Successful!</h1><p>Token has been stored.</p><p>You can close this window and restart Cursor.</p></body></html>"""
+                        self.wfile.write(html.encode('utf-8'))
+                        print("\n✓ Authentication successful!")
+                        print(f"✓ Token stored at: {token_path}")
+                        print("\nRestart Cursor to use Aurora MCP.")
+                        return
+                    else:
+                        print(f"\n✗ Failed to get token: {resp.status_code} - {resp.text}")
+                except Exception as e:
+                    print(f"\n✗ Error: {e}")
+            self.send_response(200)
+            self.send_header('Content-type', 'text/html')
+            self.end_headers()
+            self.wfile.write(b"<h1>Processing...</h1>")
+        def log_message(self, *args):
+            pass
+    with socketserver.TCPServer(("", 8765), CallbackHandler) as httpd:
+        print("Waiting for authentication callback...")
+        print("(Press Ctrl+C to cancel)\n")
+        try:
+            httpd.handle_request()
+        except KeyboardInterrupt:
+            print("\n\n✗ Authentication cancelled.")
+            sys.exit(1)
+if __name__ == "__main__":
+    main()

finta_aurora_mcp/fix_org_info.py ADDED Viewed

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+"""Fix org_info file to add missing founderId field."""
+import json
+import sys
+from pathlib import Path
+ORG_INFO_PATH = Path.home() / ".cursor" / "aurora_org_info.json"
+def fix_org_info():
+    """Add founderId to org_info if missing."""
+    if not ORG_INFO_PATH.exists():
+        print("Error: org_info file does not exist. Please run: aurora-authenticate")
+        return False
+    try:
+        with open(ORG_INFO_PATH) as f:
+            org_info = json.load(f)
+        print(f"Current org_info: {json.dumps(org_info, indent=2)}")
+        # Add founderId if missing
+        if not org_info.get("founderId"):
+            founder_id = org_info.get("user_id") or org_info.get("userId")
+            if founder_id:
+                org_info["founderId"] = founder_id
+                with open(ORG_INFO_PATH, 'w') as f:
+                    json.dump(org_info, f, indent=2)
+                print(f"\n✅ Updated org_info with founderId: {founder_id}")
+                print(f"Updated org_info: {json.dumps(org_info, indent=2)}")
+                return True
+            else:
+                print("\n❌ Error: No user_id found in org_info. Please re-authenticate with: aurora-authenticate")
+                return False
+        else:
+            print(f"\n✅ org_info already has founderId: {org_info.get('founderId')}")
+            return True
+    except Exception as e:
+        print(f"Error fixing org_info: {e}", file=sys.stderr)
+        return False
+if __name__ == "__main__":
+    success = fix_org_info()
+    sys.exit(0 if success else 1)

finta_aurora_mcp/mcp.py ADDED Viewed

@@ -0,0 +1,498 @@
+#!/usr/bin/env python3
+"""
+Aurora MCP Proxy Server
+This creates a local MCP server that proxies requests to the Aurora server
+with authentication. Similar to how Firebase MCP handles auth via CLI login.
+"""
+import asyncio
+import json
+import sys
+import os
+from pathlib import Path
+import httpx
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import Tool, TextContent
+AURORA_URL = "https://aurora-v1-staging-12f0e746ba305c099eb77fd9f5494283.us.langgraph.app"
+TOKEN_PATH = Path.home() / ".cursor" / "aurora_token.json"
+ORG_INFO_PATH = Path.home() / ".cursor" / "aurora_org_info.json"
+FINTA_API_URL = "https://us-central1-equity-token-stage.cloudfunctions.net"
+def get_token():
+    """Load stored token."""
+    try:
+        if TOKEN_PATH.exists():
+            with open(TOKEN_PATH) as f:
+                data = json.load(f)
+                return data.get("access_token")
+    except Exception as e:
+        print(f"Error loading token: {e}", file=sys.stderr)
+    return None
+def get_org_info():
+    """Load stored org info."""
+    try:
+        if ORG_INFO_PATH.exists():
+            with open(ORG_INFO_PATH) as f:
+                return json.load(f)
+    except Exception as e:
+        print(f"Error loading org info: {e}", file=sys.stderr)
+    return None
+async def fetch_and_store_org_info(token: str):
+    """Fetch org info from the validation endpoint and store it."""
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{FINTA_API_URL}/validateAuroraOAuthToken",
+                headers={"Authorization": f"Bearer {token}"},
+                timeout=10.0
+            )
+            if response.status_code == 200:
+                data = response.json()
+                if data.get("valid"):
+                    user_id = data.get("userId")
+                    org_info = {
+                        "organization_id": data.get("organizationId"),
+                        "organization_name": data.get("organizationName"),
+                        "user_id": user_id,
+                        "founderId": user_id,  # Required by Aurora tools (e.g., editInvestorTool)
+                        "handle": data.get("organizationId"),
+                    }
+                    with open(ORG_INFO_PATH, 'w') as f:
+                        json.dump(org_info, f, indent=2)
+                    return org_info
+    except Exception as e:
+        print(f"Error fetching org info: {e}", file=sys.stderr)
+    return None
+async def fetch_deal_info(org_info: dict, token: str = None) -> str:
+    """Fetch deal info for the organization (authenticated)."""
+    if not org_info:
+        return ""
+    handle = org_info.get("handle") or org_info.get("organization_id")
+    if not handle:
+        return ""
+    # Get token if not provided
+    if not token:
+        token = get_token()
+    try:
+        async with httpx.AsyncClient() as client:
+            url = f"{FINTA_API_URL}/fintaAI/tools/get-deal-info"
+            headers = {}
+            if token:
+                headers["Authorization"] = f"Bearer {token}"
+            response = await client.get(
+                url,
+                params={"organizationHandle": handle},
+                headers=headers,
+                timeout=15.0
+            )
+            if response.status_code == 200:
+                data = response.json()
+                return data.get("formatted", "")
+            elif response.status_code == 401:
+                print(f"Auth error fetching deal info: {response.text}", file=sys.stderr)
+    except Exception as e:
+        print(f"Error fetching deal info: {e}", file=sys.stderr)
+    return ""
+async def fetch_crm_contacts(org_info: dict, token: str = None) -> str:
+    """Fetch CRM contacts for the organization (authenticated)."""
+    if not org_info:
+        return ""
+    handle = org_info.get("handle") or org_info.get("organization_id")
+    if not handle:
+        return ""
+    # Get token if not provided
+    if not token:
+        token = get_token()
+    try:
+        async with httpx.AsyncClient() as client:
+            url = f"{FINTA_API_URL}/fintaAI/tools/list-investors"
+            headers = {}
+            if token:
+                headers["Authorization"] = f"Bearer {token}"
+            response = await client.get(
+                url,
+                params={"organizationHandle": handle},
+                headers=headers,
+                timeout=15.0
+            )
+            if response.status_code == 200:
+                data = response.json()
+                return data.get("formatted", "") or data.get("formattedInvestors", "")
+            elif response.status_code == 401:
+                print(f"Auth error fetching CRM contacts: {response.text}", file=sys.stderr)
+    except Exception as e:
+        print(f"Error fetching CRM contacts: {e}", file=sys.stderr)
+    return ""
+server = Server("aurora-proxy")
+@server.list_tools()
+async def list_tools():
+    """List available Aurora tools."""
+    token = get_token()
+    if not token:
+        return [
+            Tool(
+                name="aurora_login",
+                description="You need to authenticate first. Run: aurora-authenticate",
+                inputSchema={"type": "object", "properties": {}}
+            )
+        ]
+    # Always return aurora_chat tool (primary interface)
+    # The /mcp endpoint might not exist, so we don't rely on it
+    return [
+        Tool(
+            name="aurora_chat",
+            description="Chat with Aurora AI assistant. Aurora has access to tools like searching the web, scraping websites, querying knowledge bases, managing CRM contacts, and more.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "message": {
+                        "type": "string",
+                        "description": "Your message to Aurora. Aurora will automatically use tools as needed to answer your question."
+                    }
+                },
+                "required": ["message"]
+            }
+        )
+    ]
+@server.call_tool()
+async def call_tool(name: str, arguments: dict):
+    """Handle tool calls."""
+    token = get_token()
+    if not token:
+        return [TextContent(
+            type="text",
+            text="Not authenticated. Run: aurora-authenticate"
+        )]
+    if name == "aurora_chat":
+        return await handle_aurora_chat(token, arguments)
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{AURORA_URL}/mcp",
+                headers={
+                    "Authorization": f"Bearer {token}",
+                    "Content-Type": "application/json",
+                    "Accept": "application/json"
+                },
+                json={
+                    "jsonrpc": "2.0",
+                    "method": "tools/call",
+                    "params": {
+                        "name": name,
+                        "arguments": arguments
+                    },
+                    "id": 1
+                },
+                timeout=60.0
+            )
+            if response.status_code == 200:
+                data = response.json()
+                if "result" in data and "content" in data["result"]:
+                    return data["result"]["content"]
+                elif "error" in data:
+                    return [TextContent(
+                        type="text",
+                        text=f"Error: {data['error'].get('message', 'Unknown error')}"
+                    )]
+            else:
+                return [TextContent(
+                    type="text",
+                    text=f"Aurora server error: {response.status_code} - {response.text}"
+                )]
+    except Exception as e:
+        return [TextContent(
+            type="text",
+            text=f"Error calling Aurora: {str(e)}"
+        )]
+    return [TextContent(type="text", text="No response from Aurora")]
+async def handle_aurora_chat(token: str, arguments: dict):
+    """Handle aurora_chat by calling Aurora's thread API."""
+    message = arguments.get("message", "")
+    if not message:
+        return [TextContent(type="text", text="Error: message is required")]
+    org_info = get_org_info()
+    if not org_info:
+        org_info = await fetch_and_store_org_info(token)
+    # Ensure org_info has founderId (required by Aurora tools)
+    # If missing, try to use user_id as fallback and save it
+    if org_info:
+        if not org_info.get("founderId"):
+            # Try user_id as fallback
+            founder_id = org_info.get("user_id") or org_info.get("userId")
+            if founder_id:
+                org_info["founderId"] = founder_id
+                # Save updated org_info back to file
+                try:
+                    with open(ORG_INFO_PATH, 'w') as f:
+                        json.dump(org_info, f, indent=2)
+                except Exception as e:
+                    print(f"Warning: Could not save updated org_info: {e}", file=sys.stderr)
+        # If still missing, try to fetch fresh org_info
+        if not org_info.get("founderId"):
+            org_info = await fetch_and_store_org_info(token)
+    # Validate that we have the required fields
+    if not org_info or not org_info.get("founderId") or not org_info.get("handle"):
+        return [TextContent(
+            type="text",
+            text="Error: Missing required organization information (founderId or handle). Please re-authenticate with: aurora-authenticate"
+        )]
+    try:
+        async with httpx.AsyncClient() as client:
+            # Create a fresh thread for each request to avoid state corruption issues
+            # This ensures clean state for tool call handling
+            response = await client.post(
+                f"{AURORA_URL}/threads",
+                headers={
+                    "Authorization": f"Bearer {token}",
+                    "Content-Type": "application/json"
+                },
+                json={},
+                timeout=10.0
+            )
+            if response.status_code == 200:
+                data = response.json()
+                thread_id = data.get("thread_id")
+                if not thread_id:
+                    return [TextContent(
+                        type="text",
+                        text="Error: No thread_id returned from Aurora"
+                    )]
+            else:
+                return [TextContent(
+                    type="text",
+                    text=f"Error creating thread: {response.status_code} - {response.text}"
+                )]
+            deal_info_text, crm_contacts = await asyncio.gather(
+                fetch_deal_info(org_info, token),
+                fetch_crm_contacts(org_info, token)
+            )
+            deal_info_parts = []
+            if deal_info_text:
+                deal_info_parts.append(deal_info_text)
+            if crm_contacts:
+                crm_section = f"\n=== MY CRM CONTACTS ===\nBelow is a complete list of all investors in my CRM. When asked \"who is in my CRM\", \"list my contacts\", or similar questions, use this data directly to answer.\nColumns: Investor Name; Organization Name; Status; Amount; Time Engaged; Email\n{crm_contacts}\n=== END CRM CONTACTS ==="
+                deal_info_parts.append(crm_section)
+            deal_info = "\n".join(deal_info_parts)
+            # Ensure org_info is properly formatted for Aurora tools
+            # Double-check founderId is present before sending to Aurora
+            if not org_info.get("founderId"):
+                # Last resort: try to get it from user_id
+                founder_id = org_info.get("user_id") or org_info.get("userId")
+                if founder_id:
+                    org_info["founderId"] = founder_id
+                    print(f"Added founderId dynamically: {founder_id}", file=sys.stderr)
+                else:
+                    print(f"ERROR: org_info missing founderId and user_id: {org_info}", file=sys.stderr)
+                    return [TextContent(
+                        type="text",
+                        text="Error: Missing founderId in organization info. Please re-authenticate with: aurora-authenticate"
+                    )]
+            # Debug: Verify org_info structure
+            print(f"DEBUG: Sending org_info to Aurora: founderId={org_info.get('founderId')}, handle={org_info.get('handle')}", file=sys.stderr)
+            run_config = {
+                "configurable": {
+                    "model_name": "gpt-5-mini",
+                    "org_info": org_info,  # This must include founderId and handle
+                    "deal_info": deal_info,
+                }
+            }
+            # Use the streaming endpoint (matches webapp's approach)
+            # This ensures proper tool call handling
+            response = await client.post(
+                f"{AURORA_URL}/threads/{thread_id}/runs/stream",
+                headers={
+                    "Authorization": f"Bearer {token}",
+                    "Content-Type": "application/json",
+                    "Accept": "text/event-stream"
+                },
+                json={
+                    "assistant_id": "agent",
+                    "input": {
+                        "messages": [{"role": "human", "content": message}]
+                    },
+                    "config": run_config,
+                    "stream_mode": "messages"
+                },
+                timeout=180.0
+            )
+            if response.status_code != 200:
+                return [TextContent(
+                    type="text",
+                    text=f"Aurora server error: {response.status_code} - {response.text}"
+                )]
+            last_ai_message = None
+            buffer = ""
+            stream_complete = False
+            # Process the stream completely - this ensures all tool calls are executed
+            try:
+                async for chunk in response.aiter_bytes():
+                    if not chunk:
+                        continue
+                    buffer += chunk.decode('utf-8', errors='ignore')
+                    lines = buffer.split('\n')
+                    buffer = lines.pop() if lines else ""
+                    for line in lines:
+                        line = line.strip()
+                        if not line or line.startswith(':'):
+                            continue
+                        if line.startswith('data: '):
+                            data_str = line[6:]
+                            if data_str == '[DONE]':
+                                stream_complete = True
+                                continue
+                            try:
+                                data = json.loads(data_str)
+                                # Handle different stream event types
+                                if isinstance(data, dict):
+                                    # Check for run status updates
+                                    if data.get("event") == "end":
+                                        stream_complete = True
+                                        continue
+                                # Handle messages array from stream
+                                if isinstance(data, list):
+                                    for item in data:
+                                        role = item.get("role") or item.get("type", "")
+                                        # Skip tool messages and user messages
+                                        if role in ["tool", "user"]:
+                                            continue
+                                        # Collect AI/assistant messages (only those with actual content)
+                                        if role in ["ai", "assistant"]:
+                                            # Skip messages that only have tool calls (wait for tool execution to complete)
+                                            if (item.get("tool_calls") or item.get("additional_kwargs", {}).get("tool_calls")) and not item.get("content"):
+                                                continue
+                                            content = item.get("content", "")
+                                            # Extract text content
+                                            if isinstance(content, list):
+                                                text_parts = []
+                                                for part in content:
+                                                    if isinstance(part, dict):
+                                                        text_parts.append(part.get("text", str(part)))
+                                                    else:
+                                                        text_parts.append(str(part))
+                                                content = " ".join(text_parts)
+                                            elif isinstance(content, dict):
+                                                content = content.get("text", str(content))
+                                            if content and isinstance(content, str) and content.strip():
+                                                last_ai_message = content
+                            except json.JSONDecodeError:
+                                continue
+            except Exception as stream_error:
+                # Stream error - fall back to thread state
+                pass
+            # Wait a moment for any final processing
+            if not stream_complete:
+                await asyncio.sleep(2)
+            # Always get final state from thread to ensure we have the complete response
+            thread_response = await client.get(
+                f"{AURORA_URL}/threads/{thread_id}/state",
+                headers={"Authorization": f"Bearer {token}"},
+                timeout=10.0
+            )
+            if thread_response.status_code == 200:
+                thread_data = thread_response.json()
+                messages = thread_data.get("values", {}).get("messages", [])
+                # Find the last AI message that has actual text content (after all tool calls)
+                for msg in reversed(messages):
+                    role = msg.get("role") or msg.get("type", "")
+                    if role in ["ai", "assistant"]:
+                        # Only return messages that have content (not just tool calls)
+                        # Tool calls should have been executed by now
+                        if msg.get("tool_calls") and not msg.get("content"):
+                            continue
+                        content = msg.get("content", "")
+                        if isinstance(content, list):
+                            text_parts = []
+                            for item in content:
+                                if isinstance(item, dict):
+                                    text_parts.append(item.get("text", str(item)))
+                                else:
+                                    text_parts.append(str(item))
+                            content = " ".join(text_parts)
+                        elif isinstance(content, dict):
+                            content = content.get("text", str(content))
+                        if content and isinstance(content, str) and content.strip():
+                            return [TextContent(type="text", text=str(content))]
+            # If we got a message from the stream, use it
+            if last_ai_message:
+                return [TextContent(type="text", text=last_ai_message)]
+            return [TextContent(
+                type="text",
+                text="Aurora completed but no text response found. The response may have been tool calls only."
+            )]
+    except Exception as e:
+        return [TextContent(
+            type="text",
+            text=f"Error calling Aurora: {str(e)}"
+        )]
+    return [TextContent(type="text", text="No response from Aurora")]
+async def main():
+    """Run the MCP server."""
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream,
+            write_stream,
+            server.create_initialization_options()
+        )
+if __name__ == "__main__":
+    asyncio.run(main())