Platform FAQ

• React SDK (admesh-ui-sdk): For frontend integration with tail format and product card layouts
• AdMesh Weave Node SDK (admesh-weave-node): For backend Node.js integration with weave format

• Your platform supports rich media/cards
• You want a visual, interactive experience
• You have sufficient bandwidth

• Your platform is text-based
• You want minimal UI changes
• You want lightweight integration

• Your platform is built with React
• You want tail or product card format
• You want quick frontend integration
• You need UI components for recommendations

• You need weave format (inline product cards)
• Your backend is built with Node.js
• You want to embed recommendations in LLM responses
• You need backend-side recommendation logic

• Tail Format - Clickable links within conversational text
• Product Card Layouts - Individual product recommendation cards

import { AdMeshProvider, AdMeshRecommendations } from 'admesh-ui-sdk';

export const MyApp = () => {
  const sessionId = 'user-session-123';

  return (
    <AdMeshProvider
      apiKey={process.env.REACT_APP_ADMESH_API_KEY}
      sessionId={sessionId}
    >
      <YourChatComponent />
    </AdMeshProvider>
  );
};

export const YourChatComponent = () => {
  const messages = [
    { messageId: 'msg_1', role: 'user', content: 'Show me laptops' },
    { messageId: 'msg_2', role: 'assistant', content: 'Here are some options...' }
  ];

  return (
    <div>
      {messages.map(msg => <div key={msg.messageId}>{msg.content}</div>)}
      <AdMeshRecommendations messages={messages} format="tail" />
    </div>
  );
};

• Wrap your app with <AdMeshProvider> and pass sessionId
• Use <AdMeshRecommendations> to display recommendations
• The SDK handles message deduplication and recommendation fetching automatically

• Purpose: Track recommendations across a conversation
• Format: Any string (e.g., 'user-session-123')
• Scope: Should be unique per user session
• Lifetime: Persists for the duration of the conversation

​

Example:

// Generate a unique session ID for each user
const sessionId = `user-${Date.now()}`;

<AdMeshProvider apiKey={apiKey} sessionId={sessionId}>
  <App />
</AdMeshProvider>

​

Best Practices:

• Generate a new sessionId for each user session
• Store it in state or context
• Pass the same sessionId throughout the conversation
• Don’t change sessionId mid-conversation

• chatId = Perplexica’s internal chat identifier
• sessionId = AdMesh session identifier (passed to AdMeshProvider)

• Tailwind CSS
• Bootstrap
• Material-UI
• Chakra UI
• Styled Components
• Emotion

1. Install SDK: npm install admesh-weave-node
2. Initialize SDK: Set up with your API key
3. Call Recommendation API: Get recommendations for user query
4. Embed in LLM Response: Integrate recommendations into your LLM response
5. Track Interactions: Fire exposure, click, and conversion pixels

{
  "recommendations": [
    {
      "id": "rec_123",
      "title": "Product Name",
      "description": "Product description",
      "image_url": "https://...",
      "price": "$99.99",
      "click_url": "https://track.useadmesh.com/click?...",
      "exposure_pixel": "https://track.useadmesh.com/exposure?..."
    }
  ]
}

• Call AdMesh Weave Node SDK to get recommendations
• Format recommendations as product cards
• Embed cards in LLM response text
• Return complete response to frontend

• Display the LLM response with embedded cards
• Fire exposure pixel when card is shown
• Fire click pixel when user clicks
• Handle card interactions

// Fire exposure pixel when card is shown
const exposurePixel = new Image();
exposurePixel.src = recommendation.exposure_pixel;

// Fire click pixel when user clicks
window.open(recommendation.click_url, '_blank');

// Conversions are tracked brand-side via localStorage and tracking pixels
// See brand integration guide for conversion tracking implementation

• Exposure tracking when recommendations are generated
• Click tracking via signed URLs
• Conversion tracking via tracking pixels

1. React SDK (recommended for React apps)
2. Direct API (for any platform)

import { AdMeshLayout } from 'admesh-ui-sdk';

<AdMeshLayout
  recommendations={recommendations}
  layout="tail"
/>

1. Log in to your AdMesh Dashboard
2. Go to Settings → API Keys
3. Click Generate New Key
4. Copy your API key (format: admesh_prod_xxx)
5. Store securely (never commit to version control)

• exposure_pixel: Fire when recommendation is shown
• click_url: Redirect when user clicks

• HMAC-SHA256 signature
• TTL (time-to-live, default 300 seconds)
• Nonce for idempotency

• API Response Time: < 500ms
• Recommendation Latency: < 1 second
• Pixel Firing: < 100ms
• SDK Bundle Size: ~25KB gzipped

• API Response Time: < 200ms
• Recommendation Latency: < 500ms
• Pixel Firing: < 50ms

1. Cache Recommendations: Cache results for 5-10 minutes
2. Lazy Load SDK: Load SDK only when needed
3. Batch Requests: Combine multiple requests when possible
4. Use CDN: Serve SDK from CDN for faster delivery
5. Monitor Latency: Track API response times

• Free Tier: 100 requests/minute
• Pro Tier: 1,000 requests/minute
• Enterprise: Custom limits

• 90-100: Highly relevant
• 70-89: Relevant
• 50-69: Somewhat relevant
• < 50: Not relevant

1. Semantic Matching: Compare query embeddings with product embeddings
2. Keyword Matching: Match query keywords with product keywords
3. Category Matching: Match query intent with product categories
4. User History: Consider user’s past interactions

1. Better Product Data: Provide detailed titles, descriptions, keywords
2. Accurate Categories: Assign correct product categories
3. Rich Metadata: Include price, brand, ratings, etc.
4. Update Regularly: Keep product data current

1. Test API Key: Verify API key is valid
2. Test Endpoint: Call /recommend with test query
3. Test Rendering: Verify recommendations display correctly
4. Test Tracking: Verify pixels fire correctly
5. Test Edge Cases: Test with no results, errors, etc.

1. Check Console: Look for JavaScript errors
2. Check Network: Verify API requests are successful
3. Check Pixels: Verify tracking pixels are firing
4. Check Logs: Review server logs for errors
5. Enable Debug Mode: Add debug=true to API requests

• API key is valid and secure
• Recommendations display correctly
• Tracking pixels fire correctly
• Error handling works
• Performance meets requirements
• Mobile responsiveness works
• Accessibility is compliant
• Security is verified

1. Email: mani@useadmesh.com
2. Dashboard: Click Help → Report Bug
3. GitHub: Open issue in AdMesh repository

• Description of the issue
• Steps to reproduce
• Expected vs. actual behavior
• Screenshots/logs if applicable

1. API Key: Verify key is correct and not expired
2. Authorization Header: Ensure header format is correct
3. Endpoint URL: Verify you’re using correct endpoint
4. Request Body: Validate JSON is properly formatted
5. Network: Check internet connection

1. API Response: Verify API returns recommendations
2. Rendering: Check if recommendations are being rendered
3. Styling: Verify CSS isn’t hiding recommendations
4. JavaScript: Check for JavaScript errors in console
5. Permissions: Verify API key has correct permissions

1. Pixel URL: Verify pixel URL is correct
2. Network: Check if pixel request is being sent
3. Ad Blockers: Disable ad blockers and test
4. CORS: Verify CORS headers are correct
5. Timing: Ensure pixel fires at correct time

1. Cache Results: Cache recommendations for 5-10 minutes
2. Lazy Load: Load SDK only when needed
3. Compress: Enable gzip compression
4. CDN: Use CDN for static assets
5. Monitor: Track API response times