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

tools/getInvestorTool.py

@@ -0,0 +1,109 @@
+from langchain_core.tools import StructuredTool, ToolException
+import requests
+from pydantic.v1 import BaseModel, Field, ValidationError
+from typing import Optional
+import os
+from langchain_core.runnables.config import RunnableConfig
+
+API_BASE_URL = os.environ.get('API_BASE_URL', '')
+# API_BASE_URL = "https://us-central1-equity-token-1.cloudfunctions.net/"
+
+class getInvestorInfoInput(BaseModel):
+    investorId: Optional[str] = Field(default="", description="Investor's ID. Use this if you have the ID.")
+    investorName: Optional[str] = Field(default="", description="Investor's name (e.g., 'David Rose', 'John Smith'). Use this to search by name if you don't have the ID.")
+    investorEmail: Optional[str] = Field(default="", description="Investor's email address. Use this to search by email if you don't have the ID or name.")
+
+def call_get_investor_info(config: RunnableConfig, investorId: str = "", investorName: str = "", investorEmail: str = ""):
+    """Get investor information by ID, name, or email. This is for READ-ONLY queries to retrieve investor data."""
+    org_info = config.get('configurable', {}).get("org_info", {})
+    handle = org_info.get("handle")
+    
+    if not handle:
+        raise ToolException("Organization handle not found in config")
+    
+    # If ID provided, use direct lookup
+    if investorId:
+        url = API_BASE_URL + 'fintaAI/tools/get-investor-info'
+        params = {
+            "investorId": investorId,
+            "organizationHandle": handle
+        }
+        
+        try:
+            response = requests.get(url, params=params, timeout=10)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            raise ToolException(f"Failed to get investor info: {str(e)}")
+    
+    # If name or email provided, search first
+    elif investorName or investorEmail:
+        search_url = API_BASE_URL + "fintaAI/tools/search-investor"
+        search_params = {
+            "organizationHandle": handle,
+        }
+        
+        if investorEmail:
+            search_params["email"] = investorEmail
+        elif investorName:
+            search_params["name"] = investorName
+        
+        try:
+            search_response = requests.get(search_url, params=search_params, timeout=10)
+            search_response.raise_for_status()
+            search_result = search_response.json()
+        except requests.exceptions.RequestException as e:
+            raise ToolException(f"Failed to search for investor: {str(e)}")
+        
+        if not search_result.get("investors") or len(search_result["investors"]) == 0:
+            raise ToolException(f"No investor found with {'email: ' + investorEmail if investorEmail else 'name: ' + investorName}")
+        
+        if len(search_result["investors"]) > 1:
+            # Multiple matches - return info about all of them
+            investor_list = []
+            for inv in search_result["investors"][:5]:
+                inv_data = inv.get('investor', {})
+                investor_list.append({
+                    'id': inv['id'],
+                    'name': f"{inv_data.get('firstName', '')} {inv_data.get('lastName', '')}".strip(),
+                    'email': inv_data.get('email', ''),
+                    'status': inv.get('status', ''),
+                    'organizationName': inv_data.get('organizationName', ''),
+                })
+            
+            return {
+                'investorInfo': {
+                    'multipleMatches': True,
+                    'count': len(search_result["investors"]),
+                    'investors': investor_list,
+                    'message': f"Found {len(search_result['investors'])} investors with the same name. Here are the details:"
+                }
+            }
+        
+        # Found exactly one match - get full info using the ID
+        matched_id = search_result["investors"][0]["id"]
+        url = API_BASE_URL + 'fintaAI/tools/get-investor-info'
+        params = {
+            "investorId": matched_id,
+            "organizationHandle": handle
+        }
+        
+        try:
+            response = requests.get(url, params=params, timeout=10)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            raise ToolException(f"Failed to get investor info: {str(e)}")
+    
+    else:
+        raise ToolException("Either investorId, investorName, or investorEmail must be provided")
+
+get_investor_info_tool= StructuredTool.from_function(
+        func=call_get_investor_info,
+        name="GetInvestorInfo",
+        description="Given an input of investor ID, name, or email, this function returns all relevant investor information. Can search by investorName or investorEmail if ID is not provided.",
+        args_schema=getInvestorInfoInput,
+        return_direct=True,
+        verbose=True
+    )
+

tools/imageTool.py

@@ -0,0 +1,77 @@
+from openai import OpenAI
+from langchain_core.tools import tool
+import os
+from dotenv import load_dotenv
+
+if not os.getenv('GAE_APPLICATION'):
+    load_dotenv(dotenv_path='../../../../settings.ini')
+
+OpenAI.api_key = os.environ.get('OPENAI_API_KEY', '')
+
+client = OpenAI()
+
+# Import additional model providers for image support
+try:
+    from langchain_google_genai import ChatGoogleGenerativeAI
+except ImportError:
+    ChatGoogleGenerativeAI = None
+
+try:
+    from langchain_anthropic import ChatAnthropic
+except ImportError:
+    ChatAnthropic = None
+
+@tool
+def image_tool(query, imageUrl, model_name="gpt-4o"):
+    """Takes in images stored in Firebase URLs and returns a summary of the image.
+    
+    Args:
+        query: The text query about the image
+        imageUrl: URL of the image to analyze
+        model_name: Model to use for image analysis (default: gpt-4o)
+                    Supported: gpt-4o, gpt-4o-mini, gemini-pro, gemini-1.5-pro, 
+                              claude-3-opus, claude-3-sonnet, claude-3-haiku,
+                              claude-3.5-sonnet, claude-3.5-opus
+    """
+    # Use OpenAI for image analysis (best support for vision)
+    # Note: Gemini and Claude also support images, but OpenAI GPT-4o has the best vision capabilities
+    # For now, we'll use OpenAI, but you can extend this to support other providers
+    
+    # Check if it's a Gemini model
+    if model_name.startswith('gemini'):
+        if ChatGoogleGenerativeAI is None:
+            raise ValueError("langchain-google-genai package is required for Gemini models")
+        # Gemini vision support would go here
+        # For now, fallback to OpenAI for image analysis
+        model_name = "gpt-4o"
+    
+    # Check if it's a Claude model
+    if model_name.startswith('claude') or model_name == 'model-garden-anthropic':
+        if ChatAnthropic is None:
+            raise ValueError("langchain-anthropic package is required for Claude models")
+        # Claude vision support would go here
+        # For now, fallback to OpenAI for image analysis
+        model_name = "gpt-4o"
+    
+    # Use OpenAI for image analysis (best vision support)
+    response = client.chat.completions.create(
+        model=model_name if model_name.startswith('gpt') else "gpt-4o",
+        messages=[
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": query},
+                    *[
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": imageUrl,
+                                "detail": "high"
+                            },
+                        }
+                    ]
+                ],
+            }
+        ], stream=False
+    )
+    return response.choices[0].message.content

tools/pdfScraperTool.py

@@ -0,0 +1,31 @@
+from langchain_core.tools import tool
+import requests
+from PyPDF2 import PdfReader
+import io
+
+@tool
+def pdf_scraper_tool(pdfUrl: str) -> str:
+    """"When given any url for a PDF, this tool downloads the PDF and returns the text"""
+    return parsePDF(pdfUrl)
+
+def parsePDF(url):
+    pdf_stream = download_file(url)
+    if pdf_stream:
+        extracted_text = extract_text_from_pdf(pdf_stream)
+        return extracted_text
+    else:
+        return "Failed to download the file."
+    
+def extract_text_from_pdf(file_stream):
+    reader = PdfReader(file_stream)
+    text = ''
+    for page in reader.pages:
+        text += page.extract_text()
+    return text
+
+def download_file(url):
+    response = requests.get(url)
+    if response.status_code == 200:
+        return io.BytesIO(response.content)
+    else:
+        return None

tools/pineconeKnowledgeTool.py

@@ -0,0 +1,35 @@
+from openai import OpenAI
+from langchain_openai import OpenAIEmbeddings
+from langchain_core.tools import tool
+from langchain_pinecone import PineconeVectorStore
+from dotenv import load_dotenv
+import os
+
+client = OpenAI()
+embeddings = OpenAIEmbeddings(model="text-embedding-ada-002")
+embeddings.openai_api_key = os.environ.get('OPENAI_API_KEY', '')
+
+OpenAI.api_key = os.environ.get('OPENAI_API_KEY', '')
+PINECONE_API_KEY = os.environ.get('PINECONE_API_KEY', '')
+PINECONE_INDEX = os.environ.get('PINECONE_INDEX', '')
+
+phase_mapping = {
+    "Prepare Deal Materials": "Phase 1: Prepare Deal Materials",
+    "Prospect Target Investors": "Phase 2: Prospect Target",
+    "Deal Outreach": "Phase 3: Deal Outreach"
+}
+
+# Pinecone tool - using langchain-pinecone package (LangChain v1)
+index = PineconeVectorStore(
+    index_name=PINECONE_INDEX,
+    embedding=embeddings,
+    namespace="Finta Knowledge",
+    pinecone_api_key=PINECONE_API_KEY
+)
+
+
+@tool
+def pinecone_finta_knowledge_tool(query):
+    "Answers any questions about the Finta website with how-to-guides for using Deal Rooms, Investor Tracker CRM, how to prospect leads, the Cap Table, and anything else regarding the Finta Website."
+    retriever = index.as_retriever(search_type="similarity")
+    return retriever.invoke(query)

tools/pineconeResourceTool.py

@@ -0,0 +1,27 @@
+from openai import OpenAI
+from langchain_openai import OpenAIEmbeddings
+from langchain_core.tools import tool
+from langchain_pinecone import PineconeVectorStore
+import os
+
+client = OpenAI()
+embeddings = OpenAIEmbeddings(model="text-embedding-ada-002")
+embeddings.openai_api_key = os.environ.get('OPENAI_API_KEY', '')
+
+OpenAI.api_key = os.environ.get('OPENAI_API_KEY', '')
+PINECONE_API_KEY = os.environ.get('PINECONE_API_KEY', '')
+PINECONE_INDEX = os.environ.get('PINECONE_INDEX', '')
+
+# Pinecone tool - using langchain-pinecone package (LangChain v1)
+index = PineconeVectorStore(
+    index_name=PINECONE_INDEX,
+    embedding=embeddings,
+    namespace="Finta Resources",
+    pinecone_api_key=PINECONE_API_KEY
+)
+
+@tool
+def pinecone_finta_resource_tool(query):
+    "Answers any questions about the Finta website with how-to-guides for using Deal Rooms, Investor Tracker CRM, how to prospect leads, the Cap Table, and anything else regarding the Finta Website."
+    retriever = index.as_retriever(search_type="similarity")
+    return retriever.invoke(query)

tools/serpAPITool.py

@@ -0,0 +1,16 @@
+from langchain_core.tools import tool
+from langchain_community.utilities import SerpAPIWrapper
+import os
+
+os.environ['SERPAPI_API_KEY'] = '4978c95bcf7b0f61006102929068f302898894019ccd11e0c318094223f40a0f'
+#Serp API search
+@tool
+def serpAPITool(query: str) -> str:
+    """Searches Google for web responses"""
+    try:
+        search = SerpAPIWrapper()
+        return search.run(query)
+    except ValueError as e:
+        return f"No results found for query: {query}"
+    except Exception as e:
+        return f"Error searching Google: {str(e)}"

tools/webScraperTool.py

@@ -0,0 +1,30 @@
+from langchain_core.tools import tool
+import requests
+import os
+import logging
+
+logger = logging.getLogger(__name__)
+
+API_BASE_URL = os.environ.get('API_BASE_URL', '')
+
+cloudFunctionOrigin = API_BASE_URL + 'fintaAI/tools/scrape-website';
+#cloudFunctionOrigin ='https://us-central1-equity-token-stage.cloudfunctions.net/fintaAI/tools/scrape-website'
+#cloudFunctionOrigin = "http://localhost:5001/equity-token-stage/us-central1/fintaAI/tools/scrape-website"
+
+@tool
+def scrape_website_from_link_tool(website: str) -> str:
+    """"When given any url, this tool searches the link and returns the text"""
+    url =cloudFunctionOrigin
+    data = {
+        "url": website,
+    }
+    try:
+        response = requests.post(url, json=data)
+        response.raise_for_status()
+        return response.json().get('content', 'No content found')
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Exception occurred: {e}", exc_info=True)
+        return {"error": str(e)}
+    except ValueError as e:
+        logger.error(f"JSON decode error: {e}", exc_info=True)
+        return {"error": "Invalid JSON response"}