ai-ml-integration

仓库: miles990/claude-software-skills
安装量: 35
排名: #19653

安装

npx skills add https://github.com/miles990/claude-software-skills --skill ai-ml-integration

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' , max_tokens : 1024 , system , messages : [ { role : 'user' , content : prompt } ] , } ) ; return message . content [ 0 ] ; } // Streaming async function * streamChat ( prompt : string ) { const stream = anthropic . messages . stream ( { model : 'claude-sonnet-4-20250514' , max_tokens : 1024 , messages : [ { role : 'user' , content : prompt } ] , } ) ; for await ( const event of stream ) { if ( event . type === 'content_block_delta' && event . delta . type === 'text_delta' ) { yield event . delta . text ; } } } // Tool use async function chatWithTools ( prompt : string ) { const response = await anthropic . messages . create ( { model : 'claude-sonnet-4-20250514' , max_tokens : 1024 , tools : [ { name : 'search_database' , description : 'Search the database for relevant information' , input_schema : { type : 'object' , properties : { query : { type : 'string' , description : 'Search query' } , limit : { type : 'number' , description : 'Max results' } , } , required : [ 'query' ] , } , } , ] , messages : [ { role : 'user' , content : prompt } ] , } ) ; // Handle tool use blocks for ( const block of response . content ) { if ( block . type === 'tool_use' ) { const result = await executeSearch ( block . input ) ; // Continue with tool result... } } } 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 ( a : number [ ] , b : number [ ] ) : number { let dotProduct = 0 ; let normA = 0 ; let normB = 0 ; for ( let i = 0 ; i < a . length ; i ++ ) { dotProduct += a [ i ] * b [ i ] ; normA += a [ i ] * a [ i ] ; normB += b [ i ] * b [ i ] ; } return dotProduct / ( Math . sqrt ( normA ) * Math . sqrt ( normB ) ) ; } // Find similar items async function findSimilar ( query : string , items : Array < { text : string ; embedding : number [ ] }

, topK = 5 ) { const queryEmbedding = await getEmbedding ( query ) ; const scored = items . map ( item => ( { ... item , score : cosineSimilarity ( queryEmbedding , item . embedding ) , } ) ) ; return scored . sort ( ( a , b ) => b . score - a . score ) . slice ( 0 , 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 : string , topK = 5 , filter ? : object ) { const queryEmbedding = await getEmbedding ( query ) ; const results = await index . query ( { vector : queryEmbedding , topK , includeMetadata : true , filter , } ) ; return results . matches . map ( match => ( { id : match . id , score : match . score , ... match . metadata , } ) ) ; } 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 : Document [ ] ) : string { return docs . map ( ( doc , i ) => [Document ${ i + 1 } ]\n ${ doc . content } ) . join ( '\n\n' ) ; } private async generate ( question : string , context : string ) : Promise < string

{ const prompt = Answer the question based on the following context. If the answer is not in the context, say "I don't have enough information." Context: ${ context } Question: ${ question } Answer: ; return this . llm . generate ( 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 : documents . map ( d => d . content ) , topN : topK , } ) ; return response . results . map ( r => documents [ r . index ] ) ; } private async generate ( question : string , context : Document [ ] ) { const systemPrompt = You are a helpful assistant. Answer questions based on the provided context. Cite your sources using [1], [2], etc. ; const contextText = context . map ( ( doc , i ) => [ ${ i + 1 } ] ${ doc . content } ) . join ( '\n\n' ) ; const response = await openai . chat . completions . create ( { model : 'gpt-4o' , messages : [ { role : 'system' , content : systemPrompt } , { role : 'user' , content : Context:\n ${ contextText } \n\nQuestion: ${ question } } , ] , } ) ; return response . choices [ 0 ] . message . content ; } } 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 : string ) => ( { keyPoints } ) , ChatPromptTemplate . fromTemplate ( 'Create a summary from these key points:\n{keyPoints}' ) , model , new StringOutputParser ( ) , ] ) ; // Branching chain const routerChain = RunnableSequence . from ( [ ChatPromptTemplate . fromTemplate ( 'Classify this query as either "technical" or "general":\n{query}' ) , model , new StringOutputParser ( ) , async ( classification : string ) => { if ( classification . includes ( 'technical' ) ) { return technicalChain . invoke ( { query } ) ; } return generalChain . invoke ( { 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' , } ) ; // Create retriever const retriever = vectorStore . asRetriever ( { k : 5 , filter : { type : 'technical' } , } ) ; 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 . parsed ; } // With function calling for complex extraction const extractionTools = [ { type : 'function' as const , function : { name : 'extract_entities' , description : 'Extract named entities from text' , parameters : { type : 'object' , properties : { people : { type : 'array' , items : { type : 'object' , properties : { name : { type : 'string' } , role : { type : 'string' } , } , } , } , organizations : { type : 'array' , items : { type : 'string' } , } , dates : { type : 'array' , items : { type : 'string' } , } , } , } , } , } , ] ;

← 返回排行榜