Open Source AI Ecosystem

HuggingFace Transformers

from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
from typing import List, Dict

class HuggingFaceTools:
    def __init__(self):
        self.pipelines = {}
    
    def load_pipeline(self, task: str, model: str = None):
        if task not in self.pipelines:
            self.pipelines[task] = pipeline(task, model=model)
        return self.pipelines[task]
    
    def generate_text(self, prompt: str, max_length: int = 100) -> str:
        generator = self.load_pipeline("text-generation", "gpt2")
        result = generator(prompt, max_length=max_length, num_return_sequences=1)
        return result[0]["generated_text"]
    
    def classify_text(self, text: str, labels: List[str]) -> Dict:
        classifier = self.load_pipeline("zero-shot-classification")
        result = classifier(text, labels)
        return {
            "label": result["labels"][0],
            "score": result["scores"][0],
            "all_scores": dict(zip(result["labels"], result["scores"]))
        }
    
    def translate(self, text: str, target_lang: str = "fr") -> str:
        translator = self.load_pipeline(
            "translation_en_to_fr" if target_lang == "fr" else f"translation_en_to_{target_lang}"
        )
        result = translator(text)
        return result[0]["translation_text"]

tools = HuggingFaceTools()
generated = tools.generate_text("The future of AI is")
classification = tools.classify_text("Great product!", ["positive", "negative"])

LangChain Integration

from langchain.llms import OpenAI
from langchain.chains import LLMChain, SequentialChain
from langchain.prompts import PromptTemplate
from langchain.agents import initialize_agent, Tool

class LangChainAssistant:
    def __init__(self, api_key: str):
        self.llm = OpenAI(api_key_key=api_key, temperature=0.7)
        self.chains = {}
    
    def create_qa_chain(self) -> LLMChain:
        prompt = PromptTemplate(
            input_variables=["context", "question"],
            template="""Answer the question based on the context below.
            
Context: {context}

Question: {question}

Answer:"""
        )
        
        chain = LLMChain(llm=self.llm, prompt=prompt)
        self.chains["qa"] = chain
        return chain
    
    def create_summary_chain(self) -> LLMChain:
        prompt = PromptTemplate(
            input_variables=["text"],
            template="Summarize the following text concisely:\n\n{text}\n\nSummary:"
        )
        
        chain = LLMChain(llm=self.llm, prompt=prompt)
        self.chains["summary"] = chain
        return chain
    
    def answer_question(self, context: str, question: str) -> str:
        if "qa" not in self.chains:
            self.create_qa_chain()
        
        return self.chains["qa"].run(context=context, question=question)

assistant = LangChainAssistant(api_key="your-api-key")
answer = assistant.answer_question(
    context="Python is a programming language...",
    question="What is Python used for?"
)

vLLM for Fast Inference

from vllm import LLM, SamplingParams

class FastInference:
    def __init__(self, model_name: str = "meta-llama/Llama-2-7b"):
        self.llm = LLM(model=model_name, tensor_parallel_size=1)
        self.sampling_params = SamplingParams(
            temperature=0.8,
            top_p=0.95,
            max_tokens=512
        )
    
    def generate(self, prompts: List[str]) -> List[str]:
        outputs = self.llm.generate(prompts, self.sampling_params)
        
        return [output.outputs[0].text for output in outputs]
    
    def batch_generate(self, prompts: List[str], batch_size: int = 32) -> List[str]:
        all_outputs = []
        
        for i in range(0, len(prompts), batch_size):
            batch = prompts[i:i + batch_size]
            outputs = self.generate(batch)
            all_outputs.extend(outputs)
        
        return all_outputs

fast_llm = FastInference("meta-llama/Llama-2-7b")
responses = fast_llm.generate(["Hello!", "How are you?"])

Best Practices

• Start with pre-trained models from HuggingFace
• Use LangChain for complex LLM workflows
• Leverage vLLM or TGI for production inference
• Contribute to open source projects
• Follow licensing requirements carefully
• Monitor model updates and security patches