ai-ml-integration

name	ai-ml-integration
description	AI/ML APIs, LLM integration, and intelligent application patterns
domain	development-stacks
version	1.0.0
tags	["openai","anthropic","langchain","embeddings","rag","vector-db"]
triggers	{"keywords":{"primary":["ai","ml","llm","openai","anthropic","langchain","embedding","rag"],"secondary":["vector database","pinecone","chromadb","prompt engineering","agent","gpt"]},"context_boost":["intelligent","chatbot","nlp","machine learning"],"context_penalty":["frontend","css","ui","database"],"priority":"high"}

AI/ML Integration

Overview

Integrating AI and machine learning capabilities into applications, including LLM APIs, embeddings, and RAG patterns.

---

LLM Integration

OpenAI API

import OpenAI from 'openai';

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

// Chat completion
async function chat(messages: Array<{ role: string; content: string }>) {
  const response = await openai.chat.completions.create({
    model: 'gpt-4o',
    messages,
    temperature: 0.7,
    max_tokens: 1000,
  });

  return response.choices[0].message.content;
}

// Streaming response
async function* streamChat(prompt: string) {
  const stream = await openai.chat.completions.create({
    model: 'gpt-4o',
    messages: [{ role: 'user', content: prompt }],
    stream: true,
  });

  for await (const chunk of stream) {
    const content = chunk.choices[0]?.delta?.content;
    if (content) {
      yield content;
    }
  }
}

// Function calling
async function chatWithTools(message: string) {
  const tools = [
    {
      type: 'function' as const,
      function: {
        name: 'get_weather',
        description: 'Get current weather for a location',
        parameters: {
          type: 'object',
          properties: {
            location: { type: 'string', description: 'City name' },
            unit: { type: 'string', enum: ['celsius', 'fahrenheit'] },
          },
          required: ['location'],
        },
      },
    },
  ];

  const response = await openai.chat.completions.create({
    model: 'gpt-4o',
    messages: [{ role: 'user', content: message }],
    tools,
    tool_choice: 'auto',
  });

  const toolCall = response.choices[0].message.tool_calls?.[0];
  if (toolCall) {
    const args = JSON.parse(toolCall.function.arguments);
    // Execute the function
    const result = await executeFunction(toolCall.function.name, args);

    // Continue conversation with function result
    return openai.chat.completions.create({
      model: 'gpt-4o',
      messages: [
        { role: 'user', content: message },
        response.choices[0].message,
        {
          role: 'tool',
          tool_call_id: toolCall.id,
          content: JSON.stringify(result),
        },
      ],
    });
  }

  return response;
}

Anthropic Claude

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

const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

// Basic message
async function chat(prompt: string) {
  const message = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 1024,
    messages: [{ role: 'user', content: prompt }],
  });

  return message.content[0].type === 'text' ? message.content[0].text : '';
}

// With system prompt
async function chatWithSystem(system: string, prompt: string) {
  const message = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    : ,
    system,
    : [{ : , : prompt }],
  });

   message.[];
}


 * () {
   stream = anthropic..({
    : ,
    : ,
    : [{ : , : prompt }],
  });

    ( event  stream) {
     (event. ===  && event.. === ) {
       event..;
    }
  }
}


  () {
   response =  anthropic..({
    : ,
    : ,
    : [
      {
        : ,
        : ,
        : {
          : ,
          : {
            : { : , :  },
            : { : , :  },
          },
          : [],
        },
      },
    ],
    : [{ : , : prompt }],
  });

  
   ( block  response.) {
     (block. === ) {
       result =  (block.);
      
    }
  }
}

---

Embeddings

Text Embeddings

import OpenAI from 'openai';

const openai = new OpenAI();

// Generate embeddings
async function getEmbedding(text: string): Promise<number[]> {
  const response = await openai.embeddings.create({
    model: 'text-embedding-3-small',
    input: text,
  });

  return response.data[0].embedding;
}

// Batch embeddings
async function getEmbeddings(texts: string[]): Promise<number[][]> {
  const response = await openai.embeddings.create({
    model: 'text-embedding-3-small',
    input: texts,
  });

  return response.data.map(d => d.embedding);
}

// Cosine similarity
function cosineSimilarity(: [], : []):  {
   dotProduct = ;
   normA = ;
   normB = ;

   ( i = ; i < a.; i++) {
    dotProduct += a[i] * b[i];
    normA += a[i] * a[i];
    normB += b[i] * b[i];
  }

   dotProduct / (.(normA) * .(normB));
}


  () {
   queryEmbedding =  (query);

   scored = items.( ({
    ...item,
    : (queryEmbedding, item.),
  }));

   scored
    .( b. - a.)
    .(, topK);
}

Vector Database (Pinecone)

import { Pinecone } from '@pinecone-database/pinecone';

const pinecone = new Pinecone({
  apiKey: process.env.PINECONE_API_KEY,
});

const index = pinecone.index('my-index');

// Upsert vectors
async function upsertDocuments(documents: Document[]) {
  const vectors = await Promise.all(
    documents.map(async (doc) => ({
      id: doc.id,
      values: await getEmbedding(doc.content),
      metadata: {
        title: doc.title,
        source: doc.source,
        content: doc.content.slice(0, 1000), // Store truncated for retrieval
      },
    }))
  );

  await index.upsert(vectors);
}

// Query similar vectors
async function querySimilar(query: , topK = , ?: ) {
   queryEmbedding =  (query);

   results =  index.({
    : queryEmbedding,
    topK,
    : ,
    filter,
  });

   results..( ({
    : match.,
    : match.,
    ...match.,
  }));
}

---

RAG (Retrieval-Augmented Generation)

Basic RAG Pipeline

class RAGPipeline {
  constructor(
    private vectorStore: VectorStore,
    private llm: LLM,
    private embeddings: EmbeddingModel
  ) {}

  async query(question: string): Promise<string> {
    // 1. Retrieve relevant documents
    const relevantDocs = await this.retrieve(question);

    // 2. Build context
    const context = this.buildContext(relevantDocs);

    // 3. Generate response with context
    return this.generate(question, context);
  }

  private async retrieve(query: string, topK = 5) {
    const queryEmbedding = await this.embeddings.embed(query);

    return this.vectorStore.similaritySearch(queryEmbedding, topK);
  }

  private buildContext(docs: []):  {
     docs
      .( )
      .();
  }

    (: , : ): <> {
     prompt = ;

     ..(prompt);
  }
}

Advanced RAG with Reranking

import { CohereClient } from 'cohere-ai';

const cohere = new CohereClient({ token: process.env.COHERE_API_KEY });

class AdvancedRAG {
  async query(question: string): Promise<string> {
    // 1. Initial retrieval (over-fetch)
    const candidates = await this.vectorStore.similaritySearch(question, 20);

    // 2. Rerank with cross-encoder
    const reranked = await this.rerank(question, candidates, 5);

    // 3. Generate with reranked context
    return this.generate(question, reranked);
  }

  private async rerank(query: string, documents: Document[], topK: number) {
    const response = await cohere.rerank({
      model: 'rerank-english-v2.0',
      query,
      : documents.( d.),
      : topK,
    });

     response..( documents[r.]);
  }

    () {
     systemPrompt = ;

     contextText = context
      .( )
      .();

     response =  openai...({
      : ,
      : [
        { : , : systemPrompt },
        { : , :  },
      ],
    });

     response.[]..;
  }
}

---

LangChain

Chain Composition

import { ChatOpenAI } from '@langchain/openai';
import { StringOutputParser } from '@langchain/core/output_parsers';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { RunnableSequence } from '@langchain/core/runnables';

const model = new ChatOpenAI({ model: 'gpt-4o' });

// Simple chain
const prompt = ChatPromptTemplate.fromTemplate(
  'Summarize the following text in {style} style:\n\n{text}'
);

const chain = prompt.pipe(model).pipe(new StringOutputParser());

const result = await chain.invoke({
  style: 'professional',
  text: 'Long text to summarize...',
});

// Chain with multiple steps
const analysisChain = RunnableSequence.from([
  ChatPromptTemplate.fromTemplate('Extract key points from:\n{text}'),
  model,
  new StringOutputParser(),
  () => ({ keyPoints }),
  .(),
  model,
   (),
]);


 routerChain = .([
  .(
    
  ),
  model,
   (),
   (: ) => {
     (classification.()) {
       technicalChain.({ query });
    }
     generalChain.({ query });
  },
]);

Document Loading and Splitting

import { PDFLoader } from 'langchain/document_loaders/fs/pdf';
import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
import { OpenAIEmbeddings } from '@langchain/openai';
import { PineconeStore } from '@langchain/pinecone';

// Load documents
const loader = new PDFLoader('document.pdf');
const docs = await loader.load();

// Split into chunks
const splitter = new RecursiveCharacterTextSplitter({
  chunkSize: 1000,
  chunkOverlap: 200,
  separators: ['\n\n', '\n', ' ', ''],
});

const chunks = await splitter.splitDocuments(docs);

// Create vector store
const vectorStore = await PineconeStore.fromDocuments(
  chunks,
  new OpenAIEmbeddings(),
  {
    pineconeIndex: index,
    namespace: 'documents',
  }
);


 retriever = vectorStore.({
  : ,
  : { :  },
});

---

Structured Output

import { z } from 'zod';
import OpenAI from 'openai';
import { zodResponseFormat } from 'openai/helpers/zod';

const PersonSchema = z.object({
  name: z.string(),
  age: z.number(),
  occupation: z.string(),
  skills: z.array(z.string()),
});

async function extractPerson(text: string) {
  const response = await openai.beta.chat.completions.parse({
    model: 'gpt-4o',
    messages: [
      {
        role: 'system',
        content: 'Extract person information from the text.',
      },
      { role: 'user', content: text },
    ],
    response_format: zodResponseFormat(PersonSchema, 'person'),
  });

  return response.choices[0].message.;
}


 extractionTools = [
  {
    :   ,
    : {
      : ,
      : ,
      : {
        : ,
        : {
          : {
            : ,
            : {
              : ,
              : {
                : { :  },
                : { :  },
              },
            },
          },
          : {
            : ,
            : { :  },
          },
          : {
            : ,
            : { :  },
          },
        },
      },
    },
  },
];

---

Related Skills

• [[system-design]] - AI system architecture
• [[performance-optimization]] - ML inference optimization
• [[backend]] - API integration patterns