How to Give Claude Access to Customer Context with Nex

import os
import requests
import anthropic

NEX_API_KEY = os.environ["NEX_API_KEY"]

import Anthropic from "@anthropic-ai/sdk";

const NEX_API_KEY = process.env.NEX_API_KEY!;
const NEX_BASE_URL = "https://app.nex.ai/api/developers";

const anthropicClient = new Anthropic();

interface NexContextResponse {
  answer: string;
  sources: Array<{ name: string; type: string }>;
}

async function getCustomerContext(
  query: string,
  customerName?: string
): Promise<NexContextResponse> {
  const contextQuery = customerName ? `About ${customerName}: ${query}` : query;

  const response = await fetch(`${NEX_BASE_URL}/v1/context/ask`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${NEX_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ query: contextQuery }),
  });

  if (!response.ok) {
    throw new Error(`Nex API error: ${response.status}`);
  }

  return response.json();
}

async function askClaudeWithContext(
  userMessage: string,
  customerName?: string
): Promise<string> {
  const contextData = await getCustomerContext(userMessage, customerName);
  const sourceNames = contextData.sources.map((s) => s.name).join(", ");

  const systemPrompt = `You are a helpful assistant with access to current organizational data.

When answering questions about customers, deals, or business relationships, use the provided
organizational context below. If the context does not contain relevant information, say so clearly.

Organizational Context:
---
${contextData.answer}
---

Data sources consulted: ${sourceNames}`;

  const message = await anthropicClient.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 1024,
    system: systemPrompt,
    messages: [{ role: "user", content: userMessage }],
  });

  return (message.content[0]

def get_customer_timeline(record_id: str) -> list:
    """Get the activity timeline for a specific record."""
    headers = {"Authorization": f"Bearer {NEX_API_KEY}"}

    response = requests.get(
        f"{NEX_BASE_URL}/v1/records/{record_id}/timeline",
        headers=headers
    )
    response.raise_for_status()
    return response.json().get("events", [])


def build_context_for_call_prep(customer_name: str) -> str:
    """Build comprehensive call prep context for Claude."""

    context = get_customer_context(
        "What is the current deal stage, key contacts, recent emails, and any open issues?",
        customer_name
    )

    search_response = requests.post(
        f"{NEX_BASE_URL}/v1/search",
        headers={"Authorization": f"Bearer {NEX_API_KEY}", "Content-Type": "application/json"},
        json={"query": customer_name, "limit": 10}
    )
    search_results = search_response.json().get("results", [])

    context_parts = [
        f"## Current Account State
{context.get('answer', '')}",
        f"
## Recent Activity
" + "
".join(
            f"- {r.get('title', '')}: {r.get('summary', '')}"
            for r in search_results[:5]

def prep_call(account_name: str) -> str:
    context_query = f"""For account '{account_name}', provide:
    1. Current deal stage and deal value
    2. Key stakeholders and their roles
    3. Last 3 email interactions and their topics
    4. Any open issues or concerns mentioned
    5. Competitor mentions if any"""

    context = get_customer_context(context_query, account_name)

    response = anthropic_client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1500,
        system="You are a sales intelligence assistant. Prepare a concise call preparation brief using the provided context.",
        messages=[{
            "role": "user",
            "content": f"Context:
{context['answer']}

Create a structured call prep brief."
        }]
    )
    return response.content[0]

def handle_support_ticket(ticket_text: str, customer_email: str) -> str:
    context = get_customer_context(
        f"What is the history with customer {customer_email}? Previous tickets, product usage, and account health?",
        customer_email
    )

    response = anthropic_client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=800,
        system=f"You are a support agent. Use the customer context below to give an informed response.

Context:
{context['answer']}",
        messages=[{"role": "user", "content": f"New support ticket:
{ticket_text}"}]
    )
    return response.content[0]

class CustomerContextAgent:
    def __init__(self, customer_name: str):
        self.customer_name = customer_name
        self.conversation_history = []
        self.context = get_customer_context(
            "Provide a comprehensive overview of this customer.",
            customer_name
        )

    def chat(self, user_message: str) -> str:
        self.conversation_history.append({"role": "user", "content": user_message})

        response = anthropic_client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=1024,
            system=f"You are an account intelligence assistant for {self.customer_name}.

Account context:
{self.context['answer']