Update newest technology

README.md

@@ -9,6 +9,7 @@ app_file: app.py
 pinned: false
 license: mit
 short_description: 'Connection Search for Real World Location to a Map '
+long_description: 'This allows you to prompt to LLM searching for a Point of Interest like restaurants, parks, or any things that has location and the MCP Server will convert those location into visualizeable coordinates and display in the map"
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,7 +1,416 @@
+import asyncio
+import os
+import json
+from typing import List, Dict, Any, Union, Optional
+from contextlib import AsyncExitStack
+from pydantic import BaseModel, Field
+
 import gradio as gr
+from gradio.components.chatbot import ChatMessage
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+from anthropic import Anthropic
+from dotenv import load_dotenv
+from recom import RecommendationUI
+
+load_dotenv()
+
+# Define Pydantic models for structured responses
+class ToolResponse(BaseModel):
+	status_goal: str = Field(..., description="Status of the goal: 'completed', 'in_progress', or 'impossible'")
+	next_steps: List[str] = Field(default_factory=list, description="List of next actions needed")
+	tool_suggestions: str = Field(..., description="Analysis of whether the goal is achievable with current tools")
+	tool_result: Optional[str] = Field(None, description="Result from the tool execution")
+
+class MessageResponse(BaseModel):
+	role: str = Field(..., description="Role of the message sender")
+	content: str = Field(..., description="Content of the message")
+	metadata: Optional[Dict[str, Any]] = Field(None, description="Additional metadata for the message")
+
+
+  
+# To handle UI/UX outside of gradio_interface function. Especially when updating maps.
+_recom_UI = RecommendationUI()
+
+loop = asyncio.new_event_loop()
+asyncio.set_event_loop(loop)
+
+class MCPClientWrapper:
+	def __init__(self):
+		self.session = None
+		self.exit_stack = None
+		self.anthropic = Anthropic()
+		self.tools = []
+	
+	def connect(self, server_path: str) -> str:
+		return loop.run_until_complete(self._connect(server_path))
+	
+	async def _connect(self, server_path: str) -> str:
+		if self.exit_stack:
+			await self.exit_stack.aclose()
+		
+		self.exit_stack = AsyncExitStack()
+		
+		is_python = server_path.endswith('.py')
+		command = "python" if is_python else "node"
+		
+		server_params = StdioServerParameters(
+			command=command,
+			args=[server_path],
+			env={"PYTHONIOENCODING": "utf-8", "PYTHONUNBUFFERED": "1"}
+		)
+		
+		stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
+		self.stdio, self.write = stdio_transport
+		
+		self.session = await self.exit_stack.enter_async_context(ClientSession(self.stdio, self.write))
+		await self.session.initialize()
+		
+		response = await self.session.list_tools()
+		self.tools = [{ 
+			"name": tool.name,
+			"description": tool.description,
+			"input_schema": tool.inputSchema
+		} for tool in response.tools]
+		
+		tool_names = [tool["name"] for tool in self.tools]
+		return f"Connected to MCP server. Available tools: {', '.join(tool_names)}"
+	
+	def process_message(self, message: str, history: List[Union[Dict[str, Any], ChatMessage]]) -> tuple:
+		global current_lat,current_lon
+		current_status = "in_progress"
+		new_message = (f"Current Status: {current_status}\n" + 
+                 			f"Query: {message}\n" 
+                    + f" ,Current Coordinates: long: {current_lon}, lat: {current_lat}"
+		)
+  
+		if not self.session:
+			return history + [
+				{"role": "user", "content": new_message}, 
+				{"role": "assistant", "content": "Please connect to an MCP server first."}
+			], gr.Textbox(value="")
+		
+		after_process_msg = loop.run_until_complete(self._process_query(new_message, history))
+		return history + [{"role": "user", "content": new_message}] + after_process_msg, gr.Textbox(value="")
+	
+	async def _process_query(self, message: str, history: List[Union[Dict[str, Any], ChatMessage]]):
+		claude_messages = []
+		for msg in history:
+			if isinstance(msg, ChatMessage):
+				role, content = msg.role, msg.content
+			else:
+				role, content = msg.get("role"), msg.get("content")
+			
+			if role in ["user", "assistant", "system"]:
+				claude_messages.append({"role": role, "content": content})
+		
+		claude_messages.append({"role": "user", "content": message})
+		# First Run
+		response = self.anthropic.messages.create(
+			model="claude-3-5-sonnet-20241022",
+			max_tokens=1000,
+			messages=claude_messages,
+			tools=self.tools
+		)
+
+		result_messages = []
+		
+		for content in response.content:
+			if content.type == 'text':
+				result_messages.append(MessageResponse(
+					role="assistant",
+					content=content.text
+				).dict())
+			# If need to use tools
+			elif content.type == 'tool_use':
+				tool_name = content.name
+				tool_args = content.input
+				# The step by step tool uses
+				result_messages.append(MessageResponse(
+					role="assistant",
+					content=f"I'll use the {tool_name} tool to help answer your question.",
+					metadata={
+						"title": f"Using tool: {tool_name}",
+						"log": f"Parameters: {json.dumps(tool_args, ensure_ascii=True)}",
+						"status": "pending",
+						"id": f"tool_call_{tool_name}"
+					}
+				).dict())
+				# The parameters passed to process with the tools
+				result_messages.append(MessageResponse(
+					role="assistant",
+					content="```json\n" + json.dumps(tool_args, indent=2, ensure_ascii=True) + "\n```",
+					metadata={
+						"parent_id": f"tool_call_{tool_name}",
+						"id": f"params_{tool_name}",
+						"title": "Tool Parameters"
+					}
+				).dict())
+				# Execute the tools
+				result = await self.session.call_tool(tool_name, tool_args)
+    
+				# Status done if the tools managed to be executed
+				if result_messages and "metadata" in result_messages[-2]:
+					result_messages[-2]["metadata"]["status"] = "done"
+     
+				# The result from the tools into a message response
+				result_messages.append(MessageResponse(
+					role="assistant",
+					content="Here are the results from the tool:",
+					metadata={
+						"title": f"Tool Result for {tool_name}",
+						"status": "done",
+						"id": f"result_{tool_name}"
+					}
+				).dict())
+				# Retrieve the response content
+				result_content = result.content
+				if isinstance(result_content, list):
+					result_content = "\n".join(str(item) for item in result_content)
+				
+				try:
+					result_json = json.loads(result_content)
+					if isinstance(result_json, dict) and "type" in result_json:
+						if result_json["type"] == "image" and "url" in result_json:
+							result_messages.append(MessageResponse(
+								role="assistant",
+								content={"path": result_json["url"], "alt_text": result_json.get("message", "Generated image")},
+								metadata={
+									"parent_id": f"result_{tool_name}",
+									"id": f"image_{tool_name}",
+									"title": "Generated Image"
+								}
+							).dict())
+						else:
+							result_messages.append(MessageResponse(
+								role="assistant",
+								content="```\n" + result_content + "\n```",
+								metadata={
+									"parent_id": f"result_{tool_name}",
+									"id": f"raw_result_{tool_name}",
+									"title": "Raw Output"
+								}
+							).dict())
+				except:
+					result_messages.append(MessageResponse(
+						role="assistant",
+						content="```\n" + result_content + "\n```",
+						metadata={
+							"parent_id": f"result_{tool_name}",
+							"id": f"raw_result_{tool_name}",
+							"title": "Raw Output"
+						}
+					).dict())
+				
+				if tool_name == 'convert_entities_to_geojson_and_update_map':
+					_recom_UI.update_geojson(result.content[0].text)
+				
+				tool_response = ToolResponse(
+					status_goal="in_progress",
+					next_steps=["Analyze tool results", "Determine next actions"],
+					tool_suggestions="Current tools are sufficient for the task",
+					tool_result=result_content
+				)
+				# Reasoning whether the model should complete / stop the step due to impossible task.
+				claude_messages.append({
+					"role": "user", 
+					"content": f"""Analyze if the tools have accomplished the user's goal and what needs to be done next. 
+					Tool result for {tool_name}: {result_content}"""
+					"""Respond with JSON in this exact format:
+					\{
+							"status_goal": "Look at the available tools first and decide the status of next step: 
+       												completed (the current result is aligned with user's goal
+                   						|in_progress (the next step could be done with the current set of tools
+                         		|impossible (It's impossible to achieve the user's goal with the current tools)",
+							"next_steps": ["action1", "action2"],
+							"tool_suggestions": "your analysis here.",
+							"tool_result": "look at the existing result"
+					\}
+     			"""
+				})
+    
+				# Retreive the next response.
+				next_response = self.anthropic.messages.create(
+					model="claude-3-5-sonnet-20241022",
+					max_tokens=1000,
+					messages=claude_messages,
+					tools=self.tools
+				)
+				
+				try:
+					import re
+					
+					# Search for JSON pattern in the response text using regex because
+					json_match = re.search(r'\{.*\}', next_response.content[0].text, re.DOTALL)
+					
+					# Parse the matched JSON string if found, otherwise use empty dict
+					next_response_json = json.loads(json_match.group(0).replace("\n","")) if json_match else {}
+					
+					# Create ToolResponse object from parsed JSON data
+					# ** operator unpacks the dictionary into keyword arguments
+					tool_response = ToolResponse(**next_response_json)
+					
+					# Check if the tool execution is still in progress
+					if tool_response.status_goal == "in_progress":
+						# Recursively process the query with updated messages
+						recursive_messages = await self._process_query(next_response.content[0].text, claude_messages)
+						# Extend the result messages list with new recursive messages
+						result_messages.extend(recursive_messages)
+
+				except json.JSONDecodeError as e:
+					print(f"Failed to parse response as JSON {e} : {next_response.content[0]}")
+					
+				if next_response.content and next_response.content[0].type == 'text':
+					result_messages.append(MessageResponse(
+						role="assistant",
+						content=next_response.content[0].text
+					).dict())
+
+		return result_messages
+
+client = MCPClientWrapper()
+# Store selected coordinates
+current_lat = -6.1944
+current_lon = 106.8229
+
+   
+def refreshed_map():
+	global _recom_UI
+	import plotly.graph_objects as go
+	import geopandas as gpd
+	import pandas as pd
+	import subprocess
+	import urllib.parse
+  
+	"""
+	Function to refresh the map with new GeoJSON data.
+	This can be called from anywhere to update the map.
+	"""
+	df_points = pd.DataFrame()
+	
+	fig = go.Figure()
+	# Add the current location marker
+	fig.add_trace(go.Scattermapbox(
+			lat=[current_lat],
+			lon=[current_lon],
+			mode='markers',
+			marker=dict(size=20, color='blue'),
+			name='Current Location',
+			hovertemplate='Jakarta Map Data<br>Lat: %{lat}<br>Lon: %{lon}<extra></extra>'
+	))
+
+	# Add GeoJSON data if available
+	if _recom_UI.get_current_geojson()['features']:
+		existing_feature = _recom_UI.get_current_geojson()['features']
+		gdf = gpd.GeoDataFrame.from_features(existing_feature)
+		df_points = pd.DataFrame(gdf.drop(columns='geometry'))
+		df_points['url'] = df_points.apply(lambda x: f"https://maps.google.com/?q={x['name'].replace(' ','+')}",axis=1)
+		df_points['url2'] = df_points.apply(lambda x: f"https://maps.google.com/?ll={x['latitude']},{x['longitude']}",axis=1)
+  
+		# Add the DataFrame points
+		fig.add_trace(go.Scattermapbox(
+			lat=df_points["latitude"],
+			lon=df_points["longitude"],
+			mode='markers',
+			marker=dict(size=10, color='red'),
+			name='Points of Interest',
+			text=df_points["name"],
+			hovertemplate='<b>%{text}</b><br>' +
+										'Location: %{customdata[0]}<br>' +
+										'Description: %{customdata[1]}<br>' +
+										'URL by Name: <a href="%{customdata[2]}" target="_blank" style="color: #007bff; text-decoration: underline;">%{customdata[2]}</a><br>' +
+										'URL by Coordinates: <a href="%{customdata[3]}" target="_blank" style="color: #007bff; text-decoration: underline;">%{customdata[2]}</a><br>' +
+          					'Lat: %{lat}<br>Lon: %{lon}<extra></extra>',
+			customdata=df_points[["location", "description", 'url','url2']].values
+	))
+  
+	fig.update_layout(
+			mapbox_style="carto-positron",
+			mapbox=dict(
+					center=dict(lat=current_lat, lon=current_lon),
+					zoom=12
+			),
+			margin=dict(l=0, r=0, t=0, b=0),
+			height=600,
+			dragmode='pan',
+			showlegend=True
+	)
+ 
+	# Activate click event (Difficult)
+	# if _recom_UI.get_current_geojson()['features']:
+	# 	# Create the plot configuration with click handling
+	# 	config = {
+	# 			'displayModeBar': True,
+	# 			'displaylogo': False
+	# 	}
+	# 	# Show plot and add JavaScript callback
+	# 	fig.show(config=config)
+
+	# 	# Add the click event handling
+	# 	def open_url_in_windows(point_index):
+	# 		url = df_points.iloc[point_index]['url']
+	# 		subprocess.run(["wslview", url])
+
+	# 	fig.data[1].on_click(lambda trace, points, selector: 
+	# 			[open_url_in_windows(point.point_index) for point in points.point_indices])
+	
+	return fig
+
+def gradio_interface():
+	_demo = _recom_UI.get_demo()
+
+	with _demo:
+		gr.Markdown("# MCP Recommendation Assistant")
+		gr.Markdown("""Connect to your MCP to extract viral location like food, drinks, restaurants, parks and 
+              	any categories that exist on the internet""")
+		
+		with gr.Row(equal_height=True):
+			with gr.Column(scale=4):
+				server_path = gr.Textbox(
+					label="Server Script Path",
+					placeholder="Enter path to server script (e.g., weather.py)",
+					value="gradio_mcp_server.py"
+				)
+			with gr.Column(scale=1):
+				connect_btn = gr.Button("Connect")
+				
+		status = gr.Textbox(label="Connection Status", interactive=False)
+		
+		map = gr.Plot()
+		_demo.load(refreshed_map,[], map)
+		# btn.click(filter_map, map)
+  
+		chatbot = gr.Chatbot(
+			value=[], 
+			height=500,
+			type="messages",
+			show_copy_button=True,
+			avatar_images=("👤", "🤖")
+		)
+		
+		with gr.Row(equal_height=True):
+			msg = gr.Textbox(
+				label="Your Question",
+				placeholder="Ask about what you want to display(e.g., Top 5 nearby restaurants, clinics, hospitals or anything.)",
+				scale=4
+			)
+			
+			clear_btn = gr.Button("Clear Chat", scale=1)
+		
+		connect_btn.click(client.connect, inputs=server_path, outputs=status)
+		msg.submit(client.process_message,
+             		[msg, chatbot],
+								[chatbot, msg])
+		clear_btn.click(lambda: [], None, chatbot)
+		
+		timer = gr.Timer(10)
+		timer.tick(refreshed_map,[],outputs=[map])
 
-def greet(name):
-    return "Hello " + name + "!!"
+	return _demo
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+if __name__ == "__main__":
+	if not os.getenv("ANTHROPIC_API_KEY"):
+		print("Warning: ANTHROPIC_API_KEY not found in environment. Please set it in your .env file.")
+	
+	interface = gradio_interface()
+	interface.launch(debug=True)

gradio_mcp_server.py

@@ -0,0 +1,512 @@
+from mcp.server.fastmcp import FastMCP
+import json
+import sys
+import io
+import time
+from gradio_client import Client
+import urllib
+from pydantic import BaseModel, Field
+import os
+from recom import RecommendationUI
+
+sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
+sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8', errors='replace')
+
+
+class ExtractedInfo(BaseModel):
+    """Schema for extracted information"""
+    name: str = Field(..., description="Name of the business, organization, or entity")
+    address: str = Field(..., description="Detail address of the business or geographical information.")
+    description: str = Field(..., description="Description or summary of the entity")
+
+mcp = FastMCP("huggingface_spaces_image_display")
+
+
+@mcp.tool()
+async def reverse_geocode(latitude: float, longitude: float) -> str:
+    """Convert geographic coordinates into a human-readable address using the Nominatim API.
+    
+    This tool provides a more reliable and structured way to get location information from coordinates
+    compared to direct Google searches. It's particularly useful when:
+    - Working with GPS coordinates from devices or applications
+    - Need precise address information for a specific location
+    - Want to avoid the limitations of browser-based coordinate searches
+    - Need programmatic access to location data
+    
+    The tool uses OpenStreetMap's Nominatim service, which provides detailed address components
+    including street names, neighborhoods, cities, states, and countries. This structured approach
+    is more reliable than trying to interpret coordinate-based Google search results.
+    
+    Args:
+        latitude: The latitude coordinate (must be between -90 and 90)
+        longitude: The longitude coordinate (must be between -180 and 180)
+        
+    Returns:
+        A JSON string containing:
+        - type: "address" for successful geocoding or "error" for failures
+        - content: Structured address data including:
+            - display_name: Full formatted address
+            - road: Street name
+            - suburb: Neighborhood or district
+            - city: City or town
+            - state: State or region
+            - country: Country name
+            - postcode: Postal/ZIP code
+        - message: Status message about the geocoding result
+        
+    Example:
+        >>> result = await reverse_geocode(40.7128, -74.0060)
+        >>> print(result)
+        {
+            "type": "address",
+            "content": {
+                "display_name": "New York, NY, USA",
+                "road": "Broadway",
+                "suburb": "Manhattan",
+                "city": "New York",
+                "state": "New York",
+                "country": "United States",
+                "postcode": "10007"
+            },
+            "message": "Found address for coordinates: 40.7128, -74.0060"
+        }
+        
+    Usage Notes:
+        - More reliable than browser-based coordinate searches
+        - Provides structured, machine-readable address data
+        - Can be used programmatically in applications
+        - Respects rate limits and usage policies
+        - Works well for both urban and rural locations
+    """
+    try:
+        import requests
+        
+        # Use Nominatim API for reverse geocoding
+        url = f"https://nominatim.openstreetmap.org/reverse?format=json&lat={latitude}&lon={longitude}"
+        headers = {
+            'User-Agent': 'MCPGeocodingTool/1.0'  # Required by Nominatim's usage policy
+        }
+        
+        response = requests.get(url, headers=headers)
+        response.raise_for_status()
+        
+        data = response.json()
+        
+        # Extract relevant address components
+        address = {
+            "display_name": data.get("display_name", ""),
+            "road": data.get("address", {}).get("road", ""),
+            "suburb": data.get("address", {}).get("suburb", ""),
+            "display_name": data.get("display_name", ""),
+            "city": data.get("address", {}).get("city", ""),
+            "state": data.get("address", {}).get("state", ""),
+            "country": data.get("address", {}).get("country", ""),
+            "postcode": data.get("address", {}).get("postcode", "")
+        }
+        
+        return json.dumps({
+            "type": "address",
+            "content": address,
+            "message": f"Found address for coordinates: {latitude}, {longitude}"
+        })
+        
+    except Exception as e:
+        return json.dumps({
+            "type": "error",
+            "message": f"Error performing reverse geocoding: {str(e)}"
+        })
+    
+@mcp.tool()
+async def extract_links(query: str, exclude_external: bool = True, exclude_social: bool = True) -> str:
+    """Extract and analyze relevant links from Google search results based on a user's query.
+    
+    This tool performs a Google search for the given query and extracts structured information
+    about the search results. It's designed to help users find relevant resources and information
+    related to their specific goals or needs. The tool is particularly useful for:
+    - Research and information gathering
+    - Finding authoritative sources on a topic
+    - Discovering related resources and references
+    - Building a knowledge base for a specific subject
+    
+    The extracted links are filtered and categorized to provide the most relevant results,
+    excluding external and social media links by default to focus on primary content sources.
+    
+    Args:
+        query: The search query string that describes the user's information need or goal
+        exclude_external: Whether to exclude links to external websites (default: True)
+        exclude_social: Whether to exclude social media platform links (default: True)
+        
+    Returns:
+        A JSON string containing:
+        - type: "link_analysis" for successful extraction or "error" for failures
+        - content: Structured data with internal and external links
+        - message: Summary of the extraction results
+        
+    Example:
+        >>> result = await extract_links("best practices for machine learning")
+        >>> print(result)
+        {
+            "type": "link_analysis",
+            "content": {
+                "internal": [
+                    {"href": "https://example.com/ml-guide", "text": "ML Best Practices Guide"},
+                    {"href": "https://example.com/tutorials", "text": "ML Tutorials"}
+                ],
+                "external": [
+                    {"href": "https://external.com/ml-resources", "text": "External Resources"}
+                ]
+            },
+            "message": "Found 2 internal and 1 external links"
+        }
+        
+    Usage Notes:
+        - Use this tool as the first step in information gathering
+        - The extracted links can be used with extract_entity_info() to get detailed information
+        - Adjust exclude_external and exclude_social parameters based on your specific needs
+        - For academic research, consider setting exclude_external=False to get a broader range of sources
+    """
+    url = f"https://www.google.com/search?q={urllib.parse.quote(query)}"
+
+    try:
+        from crawl4ai import AsyncWebCrawler, CacheMode, CrawlerRunConfig
+        
+        async with AsyncWebCrawler() as crawler:
+            config = CrawlerRunConfig(
+                cache_mode=CacheMode.ENABLED,
+                exclude_external_links=exclude_external,
+                exclude_social_media_links=exclude_social
+            )
+            
+            result = await crawler.arun(
+                url=url,
+                config=config
+            )
+            
+            # Format results as structured data
+            links_data = {
+                "internal": [
+                    {
+                        "href": link["href"],
+                        "text": link["text"]
+                    } for link in result.links["internal"]
+                ],
+                "external": [
+                    {
+                        "href": link["href"],
+                        "text": link["text"]
+                    } for link in result.links["external"]
+                ]
+            }
+            
+            return json.dumps({
+                "type": "link_analysis",
+                "content": links_data,
+                "message": f"Use this links to pass to extract_entity_info. Total links exists: {len(links_data)}"
+            })
+            
+    except Exception as e:
+        return json.dumps({
+            "type": "error",
+            "message": f"Error extracting links: {str(e)}"
+        })
+
+@mcp.tool()
+async def extract_entity_info(urls_list: list, 
+                              user_query: str, 
+                              anthrophic_api_key:str = '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'
+                              ) -> str:
+    """Extract structured entity information from a website URL using AI-powered web crawling.
+    
+    This tool uses advanced web crawling and LLM-based extraction to identify and extract key information
+    about an entity (business, organization, or location) from a given website. It specifically looks for:
+    - Name: The official name or title of the entity
+    - Location: Physical address or geographical information
+    - Description: A concise summary of the entity's purpose or activities
+    
+    The extraction is performed using an AI model that understands webpage context and can identify
+    relevant information even when it's not explicitly labeled. The tool excludes navigation elements,
+    footers, and other non-content areas to focus on the main information.
+    
+    Args:
+        urls_list: List of the url you want to extracts.
+        user_query: The goal of the user asking you.
+        
+    Returns:
+        A JSON string containing:
+        - type: Either "entity_info" for successful extraction or "error" for failures
+        - content: The extracted information in a structured format
+        - message: A status message describing the result
+        
+    Example:
+        >>> result = await extract_entity_info("https://example.com")
+        >>> print(result)
+        {
+            "type": "entity_info",
+            "content": {
+                "name": "Example Corp",
+                "location": "123 Main St, City, Country",
+                "description": "Leading provider of example services"
+            },
+            "message": "Successfully extracted entity information from https://example.com"
+        }
+    """
+    try:
+        from crawl4ai import AsyncWebCrawler, CacheMode, CrawlerRunConfig, LLMExtractionStrategy, LLMConfig
+        from pydantic import BaseModel
+        from typing import Optional
+        # Convert results to GeoJSON format
+        import geopandas as gpd
+        from shapely.geometry import Point
+        import pandas as pd
+        # # Verify API key is available
+        # api_key = os.getenv("ANTHROPIC_API_KEY")
+        # if not api_key:
+        #     raise ValueError("ANTHROPIC_API_KEY environment variable is not set")
+        
+        # print(f"API Key found: {'*' * 4}{api_key[-4:] if api_key else 'None'}")  # Only print last 4 chars for security
+
+        # Initialize crawler with LLM extraction strategy
+        extraction_strategy = LLMExtractionStrategy(
+            llm_config=LLMConfig(
+                provider="anthropic/claude-3-5-sonnet-20241022",
+                api_token=anthrophic_api_key
+            ),
+            schema=ExtractedInfo.schema(),
+            extraction_type="schema",
+            instruction=f"""
+                REMEMBER USER'S QUERIES: {user_query}
+                Extract the following information from the website:
+                1. Name: The main name, title, or business name of the entity, according to the user's queries
+                2. Location: Any address, location, or geographical information, according to the user's queries
+                3. Description: A brief description or summary of what this entity does or is about.
+
+                Be concise and accurate. If information is not available, use "Not found" as the value.
+            """
+        )
+        async with AsyncWebCrawler(verbose=True) as crawler:
+            config = CrawlerRunConfig(
+                cache_mode=CacheMode.ENABLED,
+                extraction_strategy=extraction_strategy,
+                excluded_tags=['nav', 'footer', 'script', 'style'],
+                remove_overlay_elements=True,
+                word_count_threshold=1
+            )
+
+            results = []
+            extracted_data_list = []
+            for url in urls_list:
+                result = await crawler.arun(url=url, config=config)
+                if result.success:
+                    extracted_data = json.loads(result.extracted_content)
+                    extracted_data_list.extend(extracted_data)
+                else:
+                    print(f"Failed to extract entity information from {url}")
+            
+            results.append({
+                "type": "entity_info",
+                "content": extracted_data_list,
+                "message": f"Successfully extracted entity information from {len(urls_list)} URLs"
+            })
+            
+            return json.dumps({
+                "type": "batch_results",
+                "content": results,
+                "message": f"Processed {len(urls_list)} URLs"
+            })
+
+    except Exception as e:
+        return json.dumps({
+            "type": "error",
+            "message": f"Error extracting entity information: {str(e)}"
+        })
+
+@mcp.tool()
+async def extract_coordinates_from_address(entity_info :list):
+    """Extract geographical coordinates for entities using Google Maps automation.
+    
+    This function takes a list of entities and uses automated browser interaction with Google Maps
+    to find and extract their precise geographical coordinates. The extracted coordinates are then
+    used by plot_geojson_unto_map to create an interactive map visualization.
+    
+    This tool is particularly useful for:
+    - Converting business/place names into precise coordinates
+    - Preparing data for map visualizations
+    - Geocoding multiple locations in batch
+    - Supporting location-based services and applications
+    
+    Args:
+        entity_info (list): A list of dictionaries containing entity information.
+            Each dictionary must contain:
+            {
+                "name": str,        # Name of the business, place, or entity
+                "location": str,    # Physical address or location details
+                "description": str  # Brief description of the entity
+            }
+    
+    Returns:
+        list: The input entity_info list with added coordinates for each entity.
+            Each entity dictionary will have an additional "coordinates" field:
+            {
+                "name": str,
+                "location": str,
+                "description": str,
+                "coordinates": [latitude, longitude]  # Added coordinates
+            }
+        
+    Example:
+        >>> entities = [{"name": "Eiffel Tower", "location": "Paris, France", "description": "Famous landmark"}]
+        >>> entities_with_coords = await extract_coordinates_from_address(entities)
+        >>> print(entities_with_coords)
+        [{
+            "name": "Eiffel Tower",
+            "location": "Paris, France",
+            "description": "Famous landmark",
+            "coordinates": [48.8584, 2.2945]
+        }]
+        
+    Notes:
+        - Uses automated browser interaction with Google Maps
+        - Handles timeouts and errors gracefully
+        - Returns coordinates in [latitude, longitude] format
+        - Must be used before plot_geojson_unto_map
+        - May take longer for large lists of entities due to browser automation
+    """
+    
+    def extract_coordinates(url):
+        import re
+        """Extract coordinates from Google Maps URL"""
+        # Pattern to match coordinates after @ symbol
+        pattern = r'@(-?\d+\.\d+),(-?\d+\.\d+)'
+        match = re.search(pattern, url)
+        if match:
+            lat, lng = match.groups()
+            return float(lat), float(lng)
+        return None
+    
+    from playwright.async_api import async_playwright, TimeoutError
+    
+    async with async_playwright() as p:
+        try:
+            for entity in entity_info:
+                name = entity.get('name', '')
+                
+                # Launch browser
+                browser = await p.chromium.launch(headless=True)
+                context = await browser.new_context(
+                    locale='en-US',  # Set language to English
+                    geolocation={'latitude': 0, 'longitude': 0},
+                    permissions=['geolocation']
+                )
+                page = await context.new_page()
+                
+                # Navigate to Google Maps
+                await page.goto('https://www.google.com/maps', wait_until='domcontentloaded')
+                
+                # Wait for search box with timeout
+                search_box = await page.wait_for_selector('input[name="q"]', timeout=10000)
+                if not search_box:
+                    print("Search box not found")
+                    await browser.close()
+                    entity['coordinates'] = None
+                    continue
+                    
+                # Enter search query
+                await search_box.fill(name)
+                await search_box.press('Enter')
+                
+                # Wait for results with a reasonable timeout
+                try:
+                    await page.wait_for_selector('[role="article"]', timeout=10000)
+                except TimeoutError:
+                    print("Results did not load within timeout")
+                
+                # Get current URL after search
+                current_url = page.url
+                
+                # Extract coordinates
+                coords = extract_coordinates(current_url)
+                if coords:
+                    entity['coordinates'] = coords
+                
+                # Close browser
+                await browser.close()
+            
+            
+            return json.dumps({"entity_info":entity_info})
+        except Exception as e:
+            print(f"An error occurred: {str(e)}")
+            if 'browser' in locals():
+                await browser.close()
+            return f"{e}"
+    
+
+@mcp.tool()
+# async def convert_entities_to_geojson_and_update_map(entity_info:list):
+async def convert_entities_to_geojson_and_update_map(entity_info:list):
+    
+    """Convert entity information with coordinates into a GeoJSON map visualization.
+    
+    This function takes entity information that has been processed by extract_coordinates_from_address
+    and converts it into a GeoJSON format for map visualization. The function is designed to work
+    in sequence with extract_coordinates_from_address, which must be called first to obtain the
+    coordinates for each entity.
+    
+    This tool is particularly useful for:
+    - Visualizing multiple locations on an interactive map
+    - Creating spatial data visualizations
+    - Displaying geographical distributions of entities
+    - Supporting location-based analysis and presentations
+    
+    Args:
+        entity_info (list): A list of dictionaries containing entity information with coordinates.
+            Each dictionary must contain:
+            {
+                "name": str,        # Name of the business, place, or entity
+                "location": str,    # Physical address or location details
+                "description": str, # Brief description of the entity
+                "coordinates": list # [latitude, longitude] coordinates from extract_coordinates_from_address
+                "url": str          # Link from the google maps
+            }
+    
+    Returns:
+        None: Plot on the map the result of all entities.
+        
+    Example:
+        >>> # First, get coordinates using extract_coordinates_from_address
+        >>> entities = [{"name": "Eiffel Tower", "location": "Paris, France", "description": "Famous landmark"}]
+        >>> entities_with_coords = await extract_coordinates_from_address(entities)
+        >>> # Then, convert to GeoJSON for visualization
+        >>> await convert_entities_to_geojson_and_update_map(entities_with_coords)
+        
+    Notes:
+        - Must be used after extract_coordinates_from_address
+        - Requires coordinates to be present in the entity_info
+        - Uses EPSG:4326 coordinate reference system
+        - Updates the map visualization in real-time
+    """
+    
+    import pandas as pd
+    from shapely import Point
+    import geopandas as gpd
+    
+    # Convert list of dictionaries to pandas DataFrame
+    df = pd.DataFrame(entity_info)
+    
+    # Extract coordinates into separate columns if they exist
+    if 'coordinates' in df.columns:
+        df[['latitude', 'longitude']] = pd.DataFrame(df['coordinates'].tolist(), index=df.index)
+        
+    # Convert DataFrame to GeoDataFrame
+    gdf = gpd.GeoDataFrame(
+        df,
+        geometry=[Point(xy) for xy in zip(df['longitude'], df['latitude'])],
+        crs="EPSG:4326"
+    )
+    
+    # Convert to GeoJSON
+    geojson_data = gdf.to_json()
+    
+    return geojson_data
+
+if __name__ == "__main__":
+    mcp.run(transport='stdio')

recom.py

@@ -0,0 +1,25 @@
+import gradio as gr
+class RecommendationUI:
+    def __init__(self):
+        self.demo = gr.Blocks()
+        # Global coordinates
+        self.current_lat = -6.1944
+        self.current_lon = 106.8229
+        self.current_geojson = {
+            "type": "FeatureCollection",
+            "features": []
+        }  # Initialize empty GeoJSON
+    
+    def get_demo(self):
+        return self.demo
+    
+    def update_geojson(self, new_geojson):
+        self.current_geojson = new_geojson
+    
+    def get_current_geojson(self):
+        import json
+        if isinstance(self.current_geojson, str):
+            return json.loads(self.current_geojson)
+        return self.current_geojson
+    
+