diff --git a/app/components/CalcResultContent.vue b/app/components/CalcResultContent.vue
index a1beb89..97fadff 100644
--- a/app/components/CalcResultContent.vue
+++ b/app/components/CalcResultContent.vue
@@ -64,7 +64,7 @@
 </template>
 
 <script setup lang="ts">
-import { GetOffersByHubDocument } from '~/composables/graphql/public/geo-generated'
+import { GetNodeDocument, NearestOffersDocument, RouteToCoordinateDocument } from '~/composables/graphql/public/geo-generated'
 import type { RouteStageItem } from '~/components/RouteStagesList.vue'
 import { GetOfferDocument, GetSupplierProfileByTeamDocument } from '~/composables/graphql/public/exchange-generated'
 
@@ -106,17 +106,68 @@ type ProductRouteOption = {
 
 const fetchOffersByHub = async () => {
   if (!productUuid.value || !destinationUuid.value) return null
-  const { client } = useApolloClient('publicGeo')
 
-  const { data } = await client.query({
-    query: GetOffersByHubDocument,
-    variables: {
-      hubUuid: destinationUuid.value,
+  // 1. Get hub node to get coordinates
+  const hubData = await execute(GetNodeDocument, { uuid: destinationUuid.value }, 'public', 'geo')
+  const hub = hubData?.node
+
+  if (!hub?.latitude || !hub?.longitude) {
+    console.warn('Hub has no coordinates')
+    return null
+  }
+
+  // 2. Find offers near hub for this product
+  const offersData = await execute(
+    NearestOffersDocument,
+    {
+      lat: hub.latitude,
+      lon: hub.longitude,
       productUuid: productUuid.value,
+      radius: 500,
       limit: 5
-    }
-  })
-  return data
+    },
+    'public',
+    'geo'
+  )
+
+  const offers = offersData?.nearestOffers || []
+
+  // 3. For each offer, get route to hub coordinates
+  const offersWithRoutes = await Promise.all(
+    offers.map(async (offer: any) => {
+      try {
+        const routeData = await execute(
+          RouteToCoordinateDocument,
+          {
+            offerUuid: offer.uuid,
+            lat: hub.latitude,
+            lon: hub.longitude
+          },
+          'public',
+          'geo'
+        )
+        return {
+          sourceUuid: offer.uuid,
+          sourceName: offer.productName,
+          sourceLat: offer.latitude,
+          sourceLon: offer.longitude,
+          distanceKm: routeData?.routeToCoordinate?.distanceKm,
+          routes: routeData?.routeToCoordinate?.routes || []
+        }
+      } catch (e) {
+        console.warn('No route found for offer:', offer.uuid, e)
+        return {
+          sourceUuid: offer.uuid,
+          sourceName: offer.productName,
+          sourceLat: offer.latitude,
+          sourceLon: offer.longitude,
+          routes: []
+        }
+      }
+    })
+  )
+
+  return { offersByHub: offersWithRoutes }
 }
 
 const { data: productRoutesData, pending, error } = await useAsyncData(
diff --git a/app/composables/useCatalogHubs.ts b/app/composables/useCatalogHubs.ts
index a731376..7952bc0 100644
--- a/app/composables/useCatalogHubs.ts
+++ b/app/composables/useCatalogHubs.ts
@@ -1,4 +1,4 @@
-import { GetNodesDocument, GetHubCountriesDocument, GetHubsForProductDocument } from '~/composables/graphql/public/geo-generated'
+import { GetNodesDocument, GetHubCountriesDocument, NearestHubsDocument } from '~/composables/graphql/public/geo-generated'
 
 const PAGE_SIZE = 24
 
@@ -52,15 +52,22 @@ export function useCatalogHubs() {
   const fetchPage = async (offset: number, replace = false) => {
     if (replace) isLoading.value = true
     try {
-      // If filtering by product, use specialized query
+      // If filtering by product, use nearestHubs with global search
+      // (center point 0,0 with very large radius to cover entire globe)
       if (filterProductUuid.value) {
         const data = await execute(
-          GetHubsForProductDocument,
-          { productUuid: filterProductUuid.value },
+          NearestHubsDocument,
+          {
+            lat: 0,
+            lon: 0,
+            radius: 20000, // 20000 km radius covers entire Earth
+            productUuid: filterProductUuid.value,
+            limit: 500 // Increased limit for global search
+          },
           'public',
           'geo'
         )
-        const next = data?.hubsForProduct || []
+        const next = data?.nearestHubs || []
         items.value = next
         total.value = next.length
         isInitialized.value = true
diff --git a/app/composables/useCatalogInfo.ts b/app/composables/useCatalogInfo.ts
index 90fcdd2..eae9c8c 100644
--- a/app/composables/useCatalogInfo.ts
+++ b/app/composables/useCatalogInfo.ts
@@ -1,11 +1,9 @@
 import type { InfoEntityType } from './useCatalogSearch'
 import {
   GetNodeDocument,
-  GetProductsNearHubDocument,
-  GetProductsBySupplierDocument,
-  GetHubsNearOfferDocument,
-  GetOffersByHubDocument,
-  GetOffersBySupplierProductDocument
+  NearestOffersDocument,
+  NearestHubsDocument,
+  RouteToCoordinateDocument
 } from '~/composables/graphql/public/geo-generated'
 import {
   GetOfferDocument,
@@ -32,17 +30,41 @@ export function useCatalogInfo() {
       const nodeData = await execute(GetNodeDocument, { uuid }, 'public', 'geo')
       entity.value = nodeData?.node
 
-      // Load products near hub
-      const productsData = await execute(
-        GetProductsNearHubDocument,
-        { hubUuid: uuid, radiusKm: 500 },
+      if (!entity.value?.latitude || !entity.value?.longitude) {
+        console.warn('Hub has no coordinates')
+        return
+      }
+
+      // Load offers near hub and group by product
+      const offersData = await execute(
+        NearestOffersDocument,
+        {
+          lat: entity.value.latitude,
+          lon: entity.value.longitude,
+          radius: 500
+        },
         'public',
         'geo'
       )
-      relatedProducts.value = productsData?.productsNearHub || []
 
-      // Set default active tab to products
-      activeTab.value = 'products'
+      // Group offers by product
+      const productsMap = new Map<string, any>()
+      offersData?.nearestOffers?.forEach((offer: any) => {
+        if (offer?.productUuid) {
+          if (!productsMap.has(offer.productUuid)) {
+            productsMap.set(offer.productUuid, {
+              uuid: offer.productUuid,
+              name: offer.productName,
+              offersCount: 0
+            })
+          }
+          productsMap.get(offer.productUuid)!.offersCount++
+        }
+      })
+      relatedProducts.value = Array.from(productsMap.values())
+
+      // Set default active tab to offers (first step shows products)
+      activeTab.value = 'offers'
 
       // Note: Suppliers loaded after product selection via loadOffersForHub
     } catch (error) {
@@ -53,7 +75,7 @@ export function useCatalogInfo() {
   // Load supplier info: supplier details + products
   const loadSupplierInfo = async (uuid: string) => {
     try {
-      // Load supplier node details
+      // Load supplier node details (might be geo node)
       const nodeData = await execute(GetNodeDocument, { uuid }, 'public', 'geo')
       entity.value = nodeData?.node
 
@@ -72,17 +94,41 @@ export function useCatalogInfo() {
         // Supplier profile might not exist, ignore
       }
 
-      // Load products from supplier
-      const productsData = await execute(
-        GetProductsBySupplierDocument,
-        { supplierUuid: uuid },
+      if (!entity.value?.latitude || !entity.value?.longitude) {
+        console.warn('Supplier has no coordinates')
+        return
+      }
+
+      // Load offers near supplier and group by product
+      const offersData = await execute(
+        NearestOffersDocument,
+        {
+          lat: entity.value.latitude,
+          lon: entity.value.longitude,
+          radius: 500
+        },
         'public',
         'geo'
       )
-      relatedProducts.value = productsData?.productsBySupplier || []
 
-      // Set default active tab to products
-      activeTab.value = 'products'
+      // Group offers by product
+      const productsMap = new Map<string, any>()
+      offersData?.nearestOffers?.forEach((offer: any) => {
+        if (offer?.productUuid) {
+          if (!productsMap.has(offer.productUuid)) {
+            productsMap.set(offer.productUuid, {
+              uuid: offer.productUuid,
+              name: offer.productName,
+              offersCount: 0
+            })
+          }
+          productsMap.get(offer.productUuid)!.offersCount++
+        }
+      })
+      relatedProducts.value = Array.from(productsMap.values())
+
+      // Set default active tab to offers (first step shows products)
+      activeTab.value = 'offers'
 
       // Note: Hubs will be loaded after product selection
     } catch (error) {
@@ -97,14 +143,24 @@ export function useCatalogInfo() {
       const offerData = await execute(GetOfferDocument, { uuid }, 'public', 'exchange')
       entity.value = offerData?.getOffer
 
-      // Load hubs near offer
+      if (!entity.value?.latitude || !entity.value?.longitude) {
+        console.warn('Offer has no coordinates')
+        return
+      }
+
+      // Load hubs near offer coordinates
       const hubsData = await execute(
-        GetHubsNearOfferDocument,
-        { offerUuid: uuid, limit: 12 },
+        NearestHubsDocument,
+        {
+          lat: entity.value.latitude,
+          lon: entity.value.longitude,
+          radius: 1000,
+          limit: 12
+        },
         'public',
         'geo'
       )
-      relatedHubs.value = hubsData?.hubsNearOffer || []
+      relatedHubs.value = hubsData?.nearestHubs || []
 
       // If offer has supplier UUID, load supplier profile
       if (entity.value?.teamUuid) {
@@ -143,19 +199,73 @@ export function useCatalogInfo() {
   // Load offers for hub after product selection
   const loadOffersForHub = async (hubUuid: string, productUuid: string) => {
     try {
+      const hub = entity.value
+      if (!hub?.latitude || !hub?.longitude) {
+        console.warn('Hub has no coordinates')
+        return
+      }
+
+      // 1. Find offers near hub for this product
       const offersData = await execute(
-        GetOffersByHubDocument,
-        { hubUuid, productUuid, limit: 12 },
+        NearestOffersDocument,
+        {
+          lat: hub.latitude,
+          lon: hub.longitude,
+          productUuid,
+          radius: 500,
+          limit: 12
+        },
         'public',
         'geo'
       )
-      relatedOffers.value = offersData?.offersByHub || []
 
-      // Extract unique suppliers from offers
+      const offers = offersData?.nearestOffers || []
+
+      // 2. For each offer, get route to hub
+      const offersWithRoutes = await Promise.all(
+        offers.map(async (offer: any) => {
+          try {
+            const routeData = await execute(
+              RouteToCoordinateDocument,
+              {
+                offerUuid: offer.uuid,
+                lat: hub.latitude,
+                lon: hub.longitude
+              },
+              'public',
+              'geo'
+            )
+            return {
+              ...offer,
+              sourceUuid: offer.uuid,
+              sourceName: offer.productName,
+              sourceLat: offer.latitude,
+              sourceLon: offer.longitude,
+              distanceKm: routeData?.routeToCoordinate?.distanceKm,
+              routes: routeData?.routeToCoordinate?.routes || []
+            }
+          } catch (e) {
+            // Route might not exist
+            console.warn('No route found for offer:', offer.uuid, e)
+            return {
+              ...offer,
+              sourceUuid: offer.uuid,
+              sourceName: offer.productName,
+              sourceLat: offer.latitude,
+              sourceLon: offer.longitude,
+              routes: []
+            }
+          }
+        })
+      )
+
+      relatedOffers.value = offersWithRoutes
+
+      // Extract unique suppliers from offers (use supplierUuid from offers)
       const supplierUuids = new Set<string>()
-      relatedOffers.value.forEach((offer: any) => {
-        if (offer.teamUuid) {
-          supplierUuids.add(offer.teamUuid)
+      offersWithRoutes.forEach((offer: any) => {
+        if (offer.supplierUuid) {
+          supplierUuids.add(offer.supplierUuid)
         }
       })
 
@@ -185,32 +295,53 @@ export function useCatalogInfo() {
   // Load offers for supplier after product selection
   const loadOffersForSupplier = async (supplierUuid: string, productUuid: string) => {
     try {
+      const supplier = entity.value
+      if (!supplier?.latitude || !supplier?.longitude) {
+        console.warn('Supplier has no coordinates')
+        return
+      }
+
+      // Find offers near supplier for this product
       const offersData = await execute(
-        GetOffersBySupplierProductDocument,
-        { supplierUuid, productUuid },
+        NearestOffersDocument,
+        {
+          lat: supplier.latitude,
+          lon: supplier.longitude,
+          productUuid,
+          radius: 500,
+          limit: 12
+        },
         'public',
         'geo'
       )
-      relatedOffers.value = offersData?.offersBySupplierProduct || []
 
-      // Load hubs for each offer and aggregate (limit to 12)
+      relatedOffers.value = offersData?.nearestOffers || []
+
+      // Load hubs near each offer and aggregate (limit to 12)
       const allHubs = new Map<string, any>()
       for (const offer of relatedOffers.value.slice(0, 3)) {
         // Check first 3 offers
+        if (!offer.latitude || !offer.longitude) continue
+
         try {
           const hubsData = await execute(
-            GetHubsNearOfferDocument,
-            { offerUuid: offer.uuid, limit: 5 },
+            NearestHubsDocument,
+            {
+              lat: offer.latitude,
+              lon: offer.longitude,
+              radius: 1000,
+              limit: 5
+            },
             'public',
             'geo'
           )
-          hubsData?.hubsNearOffer?.forEach((hub: any) => {
+          hubsData?.nearestHubs?.forEach((hub: any) => {
             if (!allHubs.has(hub.uuid)) {
               allHubs.set(hub.uuid, hub)
             }
           })
         } catch (e) {
-          // Hubs might not exist for this offer
+          console.warn('Error loading hubs for offer:', offer.uuid, e)
         }
 
         if (allHubs.size >= 12) break
diff --git a/app/composables/useCatalogProducts.ts b/app/composables/useCatalogProducts.ts
index 516c964..5c32af8 100644
--- a/app/composables/useCatalogProducts.ts
+++ b/app/composables/useCatalogProducts.ts
@@ -1,8 +1,11 @@
 import {
   GetProductsDocument,
-  GetProductsBySupplierDocument,
-  GetProductsNearHubDocument
+  GetNodeDocument,
+  NearestOffersDocument
 } from '~/composables/graphql/public/geo-generated'
+import {
+  GetSupplierProfileDocument
+} from '~/composables/graphql/public/exchange-generated'
 
 // Shared state
 const items = ref<any[]>([])
@@ -27,23 +30,89 @@ export function useCatalogProducts() {
       let data
 
       if (filterSupplierUuid.value) {
-        // Products from specific supplier
-        data = await execute(
-          GetProductsBySupplierDocument,
+        // Products from specific supplier - get supplier coordinates first
+        const supplierData = await execute(
+          GetSupplierProfileDocument,
           { supplierUuid: filterSupplierUuid.value },
           'public',
-          'geo'
+          'exchange'
         )
-        items.value = data?.productsBySupplier || []
+        const supplier = supplierData?.getSupplierProfile
+
+        if (!supplier?.latitude || !supplier?.longitude) {
+          console.warn('Supplier has no coordinates')
+          items.value = []
+        } else {
+          // Get offers near supplier and group by product
+          const offersData = await execute(
+            NearestOffersDocument,
+            {
+              lat: supplier.latitude,
+              lon: supplier.longitude,
+              radius: 500
+            },
+            'public',
+            'geo'
+          )
+
+          // Group offers by product
+          const productsMap = new Map<string, any>()
+          offersData?.nearestOffers?.forEach((offer: any) => {
+            if (offer?.productUuid) {
+              if (!productsMap.has(offer.productUuid)) {
+                productsMap.set(offer.productUuid, {
+                  uuid: offer.productUuid,
+                  name: offer.productName,
+                  offersCount: 0
+                })
+              }
+              productsMap.get(offer.productUuid)!.offersCount++
+            }
+          })
+          items.value = Array.from(productsMap.values())
+        }
       } else if (filterHubUuid.value) {
-        // Products near hub
-        data = await execute(
-          GetProductsNearHubDocument,
-          { hubUuid: filterHubUuid.value },
+        // Products near hub - get hub coordinates first
+        const hubData = await execute(
+          GetNodeDocument,
+          { uuid: filterHubUuid.value },
           'public',
           'geo'
         )
-        items.value = data?.productsNearHub || []
+        const hub = hubData?.node
+
+        if (!hub?.latitude || !hub?.longitude) {
+          console.warn('Hub has no coordinates')
+          items.value = []
+        } else {
+          // Get offers near hub and group by product
+          const offersData = await execute(
+            NearestOffersDocument,
+            {
+              lat: hub.latitude,
+              lon: hub.longitude,
+              radius: 500
+            },
+            'public',
+            'geo'
+          )
+
+          // Group offers by product
+          const productsMap = new Map<string, any>()
+          offersData?.nearestOffers?.forEach((offer: any) => {
+            if (offer?.productUuid) {
+              if (!productsMap.has(offer.productUuid)) {
+                productsMap.set(offer.productUuid, {
+                  uuid: offer.productUuid,
+                  name: offer.productName,
+                  offersCount: 0
+                })
+              }
+              productsMap.get(offer.productUuid)!.offersCount++
+            }
+          })
+          items.value = Array.from(productsMap.values())
+        }
       } else {
         // All products
         data = await execute(
diff --git a/app/composables/useCatalogSuppliers.ts b/app/composables/useCatalogSuppliers.ts
index c69d77b..af0a386 100644
--- a/app/composables/useCatalogSuppliers.ts
+++ b/app/composables/useCatalogSuppliers.ts
@@ -1,5 +1,5 @@
 import { GetSupplierProfilesDocument } from '~/composables/graphql/public/exchange-generated'
-import { GetSuppliersForProductDocument } from '~/composables/graphql/public/geo-generated'
+import { NearestSuppliersDocument } from '~/composables/graphql/public/geo-generated'
 
 const PAGE_SIZE = 24
 
@@ -24,29 +24,22 @@ export function useCatalogSuppliers() {
   const fetchPage = async (offset: number, replace = false) => {
     if (replace) isLoading.value = true
     try {
-      // If filtering by product, use specialized query
+      // If filtering by product, use nearestSuppliers with global search
+      // (center point 0,0 with very large radius to cover entire globe)
       if (filterProductUuid.value) {
         const data = await execute(
-          GetSuppliersForProductDocument,
-          { productUuid: filterProductUuid.value },
+          NearestSuppliersDocument,
+          {
+            lat: 0,
+            lon: 0,
+            radius: 20000, // 20000 km radius covers entire Earth
+            productUuid: filterProductUuid.value,
+            limit: 500 // Increased limit for global search
+          },
           'public',
           'geo'
         )
-        const supplierUuids = (data?.suppliersForProduct || []).map(s => s?.uuid).filter(Boolean)
-        // Fetch full profiles for these suppliers
-        if (supplierUuids.length > 0) {
-          const profilesData = await execute(
-            GetSupplierProfilesDocument,
-            { limit: supplierUuids.length, offset: 0 },
-            'public',
-            'exchange'
-          )
-          // Filter to only include suppliers that match the product filter
-          const allProfiles = profilesData?.getSupplierProfiles || []
-          items.value = allProfiles.filter(p => supplierUuids.includes(p.uuid))
-        } else {
-          items.value = []
-        }
+        items.value = data?.nearestSuppliers || []
         total.value = items.value.length
         isInitialized.value = true
         return
diff --git a/app/pages/catalog/hubs/[id]/index.vue b/app/pages/catalog/hubs/[id]/index.vue
index 4bef986..be51d70 100644
--- a/app/pages/catalog/hubs/[id]/index.vue
+++ b/app/pages/catalog/hubs/[id]/index.vue
@@ -43,7 +43,7 @@
 </template>
 
 <script setup lang="ts">
-import { GetNodeConnectionsDocument, GetProductsNearHubDocument } from '~/composables/graphql/public/geo-generated'
+import { GetNodeConnectionsDocument, NearestOffersDocument } from '~/composables/graphql/public/geo-generated'
 
 definePageMeta({
   layout: 'topnav'
@@ -122,17 +122,45 @@ const getMockPriceHistory = (uuid: string): number[] => {
 
 // Initial load
 try {
-  const [{ data: connectionsData }, { data: productsData }] = await Promise.all([
-    useServerQuery('hub-connections', GetNodeConnectionsDocument, { uuid: hubId.value }, 'public', 'geo'),
-    useServerQuery('products-near-hub', GetProductsNearHubDocument, { hubUuid: hubId.value, radiusKm: 500 }, 'public', 'geo')
-  ])
+  // First load hub connections to get coordinates
+  const { data: connectionsData } = await useServerQuery(
+    'hub-connections',
+    GetNodeConnectionsDocument,
+    { uuid: hubId.value },
+    'public',
+    'geo'
+  )
 
   hub.value = connectionsData.value?.nodeConnections?.hub || null
 
-  // Get products near this hub (from geo)
-  products.value = (productsData.value?.productsNearHub || [])
-    .filter((p): p is { uuid: string; name?: string | null } => p !== null && !!p.uuid)
-    .map(p => ({ uuid: p.uuid!, name: p.name || '' }))
+  // Load offers near hub and group by product
+  if (hub.value?.latitude && hub.value?.longitude) {
+    const { data: offersData } = await useServerQuery(
+      'offers-near-hub',
+      NearestOffersDocument,
+      {
+        lat: hub.value.latitude,
+        lon: hub.value.longitude,
+        radius: 500
+      },
+      'public',
+      'geo'
+    )
+
+    // Group offers by product
+    const productsMap = new Map<string, { uuid: string; name: string }>()
+    offersData.value?.nearestOffers?.forEach((offer: any) => {
+      if (offer?.productUuid) {
+        if (!productsMap.has(offer.productUuid)) {
+          productsMap.set(offer.productUuid, {
+            uuid: offer.productUuid,
+            name: offer.productName || ''
+          })
+        }
+      }
+    })
+    products.value = Array.from(productsMap.values())
+  }
 } catch (error) {
   console.error('Error loading hub:', error)
 } finally {