AI as a Service for Mobile Apps: Build AI Agents as Code

import { useTextGeneration } from '@calljmp/react-native';

export function SummaryCard({ article }: { article: string }) {
  const { result, loading, error, generate, abort } = useTextGeneration({
    prompt: 'Summarize: ' + article,
  });

  return (
    <View>
      {loading && <ActivityIndicator />}
      {error && <Text>Error: {error.message}</Text>}
      {result && <Text>{result.text}</Text>}
      <Button onPress={() => generate({ prompt: 'Summarize: ' + article })}>Retry</Button>
      <Button onPress={abort}>Cancel</Button>
    </View>
  );
}

import { useChat } from '@calljmp/react-native';

export function TravelAssistant() {
  const { messages, partialMessage, sendMessage, isSending } = useChat({
    systemPrompt: 'You are a helpful travel planner focused on budget tips.'
  });

  return (
    <View>
      {[...messages, partialMessage].filter(Boolean).map((m, i) => (
        <Text key={i}>{m!.role}: {m!.content}</Text>
      ))}
      <Button disabled={isSending} onPress={() => sendMessage('Plan 3 day Tokyo trip under $500')}>Ask</Button>
    </View>
  );
}

import calljmp from '@calljmp/react-native';

async function translateAudio(audioBlob: Blob) {
  const text = await calljmp.ai.speech.toText(audioBlob, { language: 'en' });
  const translated = await calljmp.ai.text.translate(text, 'es');
  return translated;
}

const caption = await calljmp.ai.image.toText(photoUri, {
  prompt: 'Describe for visually impaired user'
});

// or background removal
const processed = await calljmp.ai.image.removeBackground(photoUri);

const results = await calljmp.ai.search.semantic({
  query: 'refund policy',
  dataset: 'faqs',
  topK: 5,
});

results.forEach(r => console.log(r.score, r.text));

import { Calljmp, operator, workflow, OperatorContext } from '@calljmp/react-native';

const calljmp = new Calljmp();

// Operator fn for generating embeddings (async/await)
const generateEmbedding = calljmp.ai.operator<
  { query: string },
  { embedding: number[] }
>(async (context) => {
  const ai = context.env.AI;
  const embeddingResponse = await ai.run('@cf/baai/bge-base-en-v1.5', { text: [context.input.query] });
  return { embedding: embeddingResponse.data[0] };
});

// Operator fn for vector search (async, Vectorize binding)
const vectorSearch = calljmp.ai.operator<
  { embedding: number[] },
  { results: object[] }
>(async (context) => {
  const matches = await context.env.VECTORIZE.query(context.input.embedding, { topK: 10 });
  return { results: matches.matches };
});

// Operator fn for filtering results (with memory)
const filterResults = calljmp.ai.operator<
  { results: object[] },
  { filteredResults: object[] }
>(async (context) => {
  const { results } = context.input;
  const threshold = context.memory.threshold || 0.80; // Read from memory with default
  const filtered = results.filter((item) => item.score > threshold);
  return { filteredResults: filtered, _memory: { filteredCount: filtered.length } };
});

// Operator fn for AI summarization (async)
const summarizeWithAI = calljmp.ai.operator<
  { filteredResults: object[] },
  { summary: string }
>(async (context) => {
  const ai = context.env.AI;
  const summary = await ai.run('@cf/meta/llama-2-7b-chat-fp16', `Summarize: ${JSON.stringify(context.input.filteredResults)}`);
  return { summary };
});

// Operator fn for sending email notification (async, custom binding)
const sendEmailNotification = calljmp.ai.operator<
  { summary: string },
  { notificationStatus: string }
>(async (context) => {
  await context.env.EMAIL.send({
    to: 'user@example.com',
    subject: 'Summary Ready',
    body: context.input.summary,
  });
  return { notificationStatus: 'sent' };
});

// Sequential workflow with type changes
const workflow = calljmp.ai.workflow('Search Workflow', 'Embedding to Email Notification', (flow) => {
  flow.next(generateEmbedding.with({ inputs: ['query'] })); // flow.outputs.embedding: number[]
  flow.next(vectorSearch); // flow.outputs.results: object[]
  flow.next(filterResults); // flow.outputs.filteredResults: object[]; flow.memory.filteredCount: number
  flow.next(summarizeWithAI); // flow.outputs.summary: string
  flow.next(sendEmailNotification); // flow.outputs.notificationStatus: string
});