Foundry Local as Tools Integration

January 29, 2026 · View on GitHub

വലിയ ആപ്ലിക്കേഷനുകളിൽ വിളിക്കാവുന്ന ടൂളുകളായി Microsoft Foundry Local സംയോജിപ്പിക്കുന്നതിന് ഒരു സമഗ്രമായ ഫ്രെയിംവർക്ക്, ടൂൾ അടിസ്ഥാനമാക്കിയ AI സംയോജിപ്പിക്കലിനുള്ള Microsoft ന്റെ ഔദ്യോഗിക മാതൃകകൾ പിന്തുടരുന്നു.

അവലോകനം

ഈ സാമ്പിൾ നിലവിലുള്ള ആപ്ലിക്കേഷനുകളിലും വർക്ക്‌ഫ്ലോകളിലും ഡെവലപ്പ്മെന്റ് പരിസ്ഥിതികളിലും സംയോജിപ്പിക്കാവുന്ന പുനരുപയോഗയോഗ്യമായ ടൂളുകളായി Foundry Local മോഡലുകൾ എങ്ങനെ പ്രദർശിപ്പിക്കാമെന്ന് കാണിക്കുന്നു. ടൂൾ സംയോജിപ്പിക്കൽക്കും ഫംഗ്ഷൻ കോൾ ചെയ്യലിനും Microsoft ന്റെ ശുപാർശ ചെയ്ത മാതൃകകൾ ഇതിൽ കാണിക്കുന്നു.

പ്രധാന ആശയങ്ങൾ

🔧 ടൂൾ-ഫസ്റ്റ് ആർക്കിടെക്ചർ

  • വിളിക്കാവുന്ന ഫംഗ്ഷനുകളായി Foundry Local മോഡലുകൾ
  • സ്റ്റാൻഡേർഡൈസ്ഡ് ടൂൾ ഇന്റർഫേസുകളും സ്കീമകളും
  • നിലവിലുള്ള കോഡ്‌ബേസുകളുമായി സുതാര്യമായ സംയോജനം
  • ടൈപ്പ്-സേഫ് ടൂൾ നിർവചനങ്ങളും സാധുതയും

⚡ ഫംഗ്ഷൻ കോൾ ചെയ്യൽ മാതൃകകൾ

  • Microsoft Foundry Local ഫംഗ്ഷൻ കോൾ ചെയ്യൽ നടപ്പാക്കൽ
  • OpenAI-സമാനമായ ടൂൾ നിർവചനങ്ങൾ
  • സ്വയംപരിശോധനയും പരാമീറ്റർ പരിവർത്തനവും
  • പിശക് കൈകാര്യം ചെയ്യലും പ്രതികരണ ഫോർമാറ്റിംഗും

🔌 സംയോജനം ഫ്രെയിംവർക്കുകൾ

  • LangChain സംയോജനം: നേറ്റീവ് LangChain ടൂൾ പിന്തുണ
  • Semantic Kernel: Microsoft Semantic Kernel ഫംഗ്ഷനുകൾ
  • REST API: HTTP അടിസ്ഥാനമാക്കിയ ടൂൾ എൻഡ്‌പോയിന്റുകൾ
  • CLI ടൂളുകൾ: കമാൻഡ്-ലൈൻ ഇന്റർഫേസ് സംയോജനം
  • Jupyter Notebooks: ഇന്ററാക്ടീവ് ഡെവലപ്പ്മെന്റ് ടൂളുകൾ

🎯 ഉപയോഗ കേസുകൾ

  • കോഡ് വിശകലനവും സൃഷ്ടിയും
  • ഉള്ളടക്ക പ്രോസസ്സിംഗും സംഗ്രഹീകരണവും
  • ഡാറ്റ വിശകലനവും ദൃശ്യവൽക്കരണവും
  • ഗവേഷണവും വിവര ശേഖരണവും
  • തീരുമാന സഹായ സംവിധാനങ്ങൾ

ആർക്കിടെക്ചർ

┌─────────────────────────────────────────────────────────────────┐
│                    Application Layer                            │
│                                                                 │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐            │
│  │  LangChain  │  │  Semantic   │  │  Custom     │            │
│  │    Tools    │  │   Kernel    │  │    Apps     │            │
│  └─────────────┘  └─────────────┘  └─────────────┘            │
└─────────────────┬─────────────────┬─────────────────────────────┘
                  │                 │
                  ▼                 ▼
┌─────────────────────────────────────────────────────────────────┐
│                    Tool Integration Layer                       │
│                                                                 │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐            │
│  │ Function    │  │   REST      │  │    CLI      │            │
│  │ Registry    │  │  Gateway    │  │  Interface  │            │
│  └─────────────┘  └─────────────┘  └─────────────┘            │
└─────────────────────────┬───────────────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────────────┐
│                Microsoft Foundry Local Service                  │
│                                                                 │
│ • Model Management        • Function Calling Support           │
│ • Inference Engine        • Tool Schema Validation             │
│ • Context Handling        • Response Formatting                │
└─────────────────────────────────────────────────────────────────┘

മുൻ‌അവശ്യങ്ങൾ

സിസ്റ്റം ആവശ്യകതകൾ

  • Python: asyncio പിന്തുണയോടെ 3.9+
  • Node.js: v18+ (JavaScript സംയോജനംക്കായി)
  • മെമ്മറി: 12GB+ ശുപാർശ ചെയ്യുന്നു
  • സ്റ്റോറേജ്: മോഡലുകൾക്കും ടൂളുകൾക്കും 10GB+

കോർ ആശ്രിതങ്ങൾ

pip install foundry-local-sdk openai langchain semantic-kernel fastapi uvicorn typer rich

ഫ്രെയിംവർക്ക്-നിർദിഷ്ട ആശ്രിതങ്ങൾ

# ലാംഗ്‌ചെയിൻ ഇന്റഗ്രേഷൻ
pip install langchain-openai langchain-community

# സെമാന്റിക് കർണൽ ഇന്റഗ്രേഷൻ
pip install semantic-kernel

# വെബ് ഫ്രെയിംവർക്ക് ഇന്റഗ്രേഷൻ
pip install fastapi uvicorn streamlit gradio

# ഡെവലപ്പ്മെന്റ് ടൂളുകൾ
pip install jupyter ipywidgets

വേഗത്തിലുള്ള ആരംഭം

1. അടിസ്ഥാന ടൂൾ സൃഷ്ടി

from foundry_tools import FoundryTool, FoundryToolRegistry

# ഒരു ലളിതമായ വിശകലന ഉപകരണം സൃഷ്ടിക്കുക
@FoundryTool(
    name="code_analyzer",
    description="Analyze code quality and suggest improvements",
    model="phi-4-mini"
)
async def analyze_code(code: str, language: str = "python") -> dict:
    """Analyze code and return quality metrics and suggestions."""
    pass

# ഉപകരണം രജിസ്റ്റർ ചെയ്ത് ഉപയോഗിക്കുക
registry = FoundryToolRegistry()
await registry.register(analyze_code)

result = await registry.call("code_analyzer", {
    "code": "def hello(): print('world')",
    "language": "python"
})

2. LangChain സംയോജനം

from langchain.tools import BaseTool
from foundry_tools.langchain import FoundryLangChainTool

# LangChain-സഹജമായ ടൂൾ സൃഷ്ടിക്കുക
class CodeAnalyzerTool(FoundryLangChainTool):
    name = "code_analyzer"
    description = "Analyze code quality using Foundry Local"
    model = "phi-4-mini"
    
    async def _arun(self, code: str, language: str = "python") -> str:
        return await self.foundry_call({
            "code": code,
            "language": language
        })

# LangChain ഏജന്റുകളുമായി ഉപയോഗിക്കുക
from langchain.agents import initialize_agent, AgentType

tools = [CodeAnalyzerTool()]
agent = initialize_agent(
    tools=tools,
    llm=None,  # Foundry Local ഉപയോഗിക്കുന്നു
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION
)

3. REST API സംയോജനം

from fastapi import FastAPI
from foundry_tools.rest import FoundryRESTEndpoint

app = FastAPI()

# Foundry ഉപകരണങ്ങളിൽ നിന്ന് REST എൻഡ്‌പോയിന്റുകൾ സ്വയം സൃഷ്ടിക്കുക
foundry_api = FoundryRESTEndpoint()
await foundry_api.register_tool("code_analyzer", analyze_code)

# എൻഡ്‌പോയിന്റുകൾ മൗണ്ട് ചെയ്യുക
app.include_router(foundry_api.router, prefix="/foundry/v1")

# HTTP വഴി ഉപയോഗിക്കുക
# POST /foundry/v1/code_analyzer
# {
#   "code": "def hello(): print('world')",
#   "language": "python"
# }

പ്രോജക്ട് ഘടന

10/
├── README.md                    # This documentation
├── requirements.txt             # Python dependencies
├── foundry_tools/
│   ├── __init__.py             # Package initialization
│   ├── core/
│   │   ├── __init__.py
│   │   ├── tool_base.py        # Base tool implementation
│   │   ├── registry.py         # Tool registry
│   │   ├── validation.py       # Schema validation
│   │   └── client.py           # Foundry Local client
│   ├── integrations/
│   │   ├── __init__.py
│   │   ├── langchain.py        # LangChain integration
│   │   ├── semantic_kernel.py  # Semantic Kernel integration
│   │   ├── rest_api.py         # REST API framework
│   │   ├── cli.py              # Command-line interface
│   │   └── jupyter.py          # Jupyter notebook tools
│   ├── frameworks/
│   │   ├── __init__.py
│   │   ├── fastapi_tools.py    # FastAPI integration
│   │   ├── streamlit_tools.py  # Streamlit integration
│   │   ├── gradio_tools.py     # Gradio integration
│   │   └── flask_tools.py      # Flask integration
│   └── tools/
│       ├── __init__.py
│       ├── code_tools.py       # Code analysis tools
│       ├── content_tools.py    # Content processing tools
│       ├── data_tools.py       # Data analysis tools
│       ├── research_tools.py   # Research and retrieval tools
│       └── decision_tools.py   # Decision support tools
├── examples/
│   ├── basic_tools.py          # Simple tool examples
│   ├── langchain_demo.py       # LangChain integration
│   ├── semantic_kernel_demo.py # Semantic Kernel demo
│   ├── rest_api_server.py      # REST API server
│   ├── cli_application.py      # CLI application
│   ├── jupyter_notebook.ipynb  # Interactive notebook
│   ├── streamlit_app.py        # Streamlit application
│   └── production_deployment.py # Production patterns
├── integrations/
│   ├── vscode_extension/       # VS Code extension
│   ├── github_actions/         # CI/CD workflows
│   ├── azure_functions/        # Serverless deployment
│   └── docker_containers/      # Containerization
└── tests/
    ├── test_tools.py           # Tool tests
    ├── test_integrations.py    # Integration tests
    └── test_frameworks.py      # Framework tests

കോർ ടൂൾ മാതൃകകൾ

1. ഫംഗ്ഷൻ അടിസ്ഥാനമാക്കിയ ടൂളുകൾ

from foundry_tools import FoundryTool
from typing import List, Dict, Any

@FoundryTool(
    name="summarize_content",
    description="Summarize long-form content into key points",
    model="phi-4-mini",
    parameters={
        "content": {"type": "string", "description": "Content to summarize"},
        "max_points": {"type": "integer", "description": "Maximum summary points", "default": 5},
        "style": {"type": "string", "description": "Summary style", "enum": ["bullet", "paragraph", "outline"]}
    }
)
async def summarize_content(
    content: str, 
    max_points: int = 5, 
    style: str = "bullet"
) -> Dict[str, Any]:
    """Summarize content using Foundry Local model."""
    
    # ഡെക്കറേറ്റർ സ്വയം കൈകാര്യം ചെയ്യുന്നു:
    # - പാരാമീറ്റർ പരിശോധന
    # - ഫൗണ്ടറി ലോക്കൽ ക്ലയന്റ് സജ്ജീകരണം
    # - പിശക് കൈകാര്യം ചെയ്യലും ലോഗിംഗും
    # - പ്രതികരണ ഫോർമാറ്റിംഗ്
    
    system_prompt = f"""
    Summarize the following content into {max_points} key points.
    Use {style} format for the summary.
    """
    
    # ഇത് സ്വയം ഫൗണ്ടറി ലോക്കലിലേക്ക് റൂട്ടുചെയ്യപ്പെടുന്നു
    return {
        "summary": "Generated summary here...",
        "points": max_points,
        "style": style,
        "word_count": len(content.split())
    }

2. ക്ലാസ് അടിസ്ഥാനമാക്കിയ ടൂളുകൾ

from foundry_tools.core import BaseFoundryTool

class CodeAnalysisTool(BaseFoundryTool):
    """Advanced code analysis tool with state management."""
    
    name = "advanced_code_analyzer"
    description = "Perform comprehensive code analysis"
    model = "phi-4-mini"
    
    def __init__(self):
        super().__init__()
        self.analysis_cache = {}
        self.supported_languages = ["python", "javascript", "typescript", "java", "csharp"]
    
    async def validate_input(self, **kwargs) -> bool:
        """Custom input validation."""
        language = kwargs.get("language", "").lower()
        return language in self.supported_languages
    
    async def execute(self, code: str, language: str, analysis_type: str = "full") -> Dict[str, Any]:
        """Execute code analysis."""
        
        # കാഷെ പരിശോധിക്കുക
        cache_key = f"{hash(code)}_{language}_{analysis_type}"
        if cache_key in self.analysis_cache:
            return self.analysis_cache[cache_key]
        
        # ഫൗണ്ട്രി ലോക്കൽ ഉപയോഗിച്ച് വിശകലനം നടത്തുക
        result = await self.foundry_call({
            "system_prompt": f"Analyze this {language} code for {analysis_type} analysis",
            "user_prompt": f"Code to analyze:\n\n```{language}\n{code}\n```",
            "max_tokens": 1000
        })
        
        # ഫലം പ്രോസസ്സ് ചെയ്ത് കാഷെ ചെയ്യുക
        analysis_result = self.process_analysis_result(result, analysis_type)
        self.analysis_cache[cache_key] = analysis_result
        
        return analysis_result
    
    def process_analysis_result(self, raw_result: str, analysis_type: str) -> Dict[str, Any]:
        """Process the raw analysis result into structured data."""
        # ഇവിടെ നടപ്പാക്കൽ
        pass

3. സ്ട്രീമിംഗ് ടൂളുകൾ

from foundry_tools import StreamingFoundryTool
from typing import AsyncGenerator

@StreamingFoundryTool(
    name="code_generator",
    description="Generate code with real-time streaming",
    model="qwen2.5-coder-0.5b"
)
async def generate_code(
    specification: str,
    language: str = "python",
    include_tests: bool = False
) -> AsyncGenerator[Dict[str, Any], None]:
    """Generate code with streaming responses."""
    
    # ആദ്യം മെറ്റാഡേറ്റ നൽകുക
    yield {
        "type": "metadata",
        "language": language,
        "include_tests": include_tests,
        "estimated_lines": 50
    }
    
    # കോഡ് ജനറേഷൻ സ്ട്രീം ചെയ്യുക
    async for chunk in foundry_stream({
        "prompt": f"Generate {language} code: {specification}",
        "stream": True
    }):
        yield {
            "type": "code_chunk",
            "content": chunk.content,
            "complete": chunk.finish_reason is not None
        }
    
    # അന്തിമ ഫലം നൽകുക
    if include_tests:
        async for test_chunk in foundry_stream({
            "prompt": f"Generate unit tests for the above {language} code",
            "stream": True
        }):
            yield {
                "type": "test_chunk", 
                "content": test_chunk.content,
                "complete": test_chunk.finish_reason is not None
            }

സംയോജനം ഉദാഹരണങ്ങൾ

LangChain സംയോജനം

from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain.prompts import ChatPromptTemplate
from foundry_tools.langchain import FoundryToolkit

# ഫൗണ്ട്രി-ചാലിത ടൂൾകിറ്റ് സൃഷ്ടിക്കുക
toolkit = FoundryToolkit()
toolkit.add_tool("code_analyzer", model="phi-4-mini")
toolkit.add_tool("content_summarizer", model="qwen2.5-0.5b") 
toolkit.add_tool("research_assistant", model="phi-3.5-mini")

# ഫൗണ്ട്രി ടൂളുകൾ ഉപയോഗിച്ച് ഏജന്റ് സൃഷ്ടിക്കുക
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant with access to Foundry Local tools."),
    ("user", "{input}"),
    ("assistant", "{agent_scratchpad}")
])

agent = create_openai_functions_agent(
    llm=toolkit.get_llm(),  # ഫൗണ്ട്രി ലോക്കൽ LLM ആയി ഉപയോഗിക്കുന്നു
    tools=toolkit.get_tools(),
    prompt=prompt
)

agent_executor = AgentExecutor(agent=agent, tools=toolkit.get_tools())

# ഏജന്റ് ഉപയോഗിക്കുക
result = await agent_executor.ainvoke({
    "input": "Analyze this Python code and summarize any issues you find"
})

Semantic Kernel സംയോജനം

from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
from foundry_tools.semantic_kernel import FoundryKernelPlugin

# ഫൗണ്ട്രി ലോക്കലുമായി കർണൽ ആരംഭിക്കുക
kernel = Kernel()

# ചാറ്റ് സേവനമായി ഫൗണ്ട്രി ലോക്കൽ ചേർക്കുക
foundry_service = OpenAIChatCompletion(
    service_id="foundry_chat",
    ai_model_id="phi-4-mini",
    api_key="not-needed",
    base_url="http://localhost:5273/v1"
)
kernel.add_service(foundry_service)

# ഫൗണ്ട്രി പ്ലഗിൻ സൃഷ്ടിച്ച് ചേർക്കുക
foundry_plugin = FoundryKernelPlugin()
foundry_plugin.add_function("analyze_code", model="phi-4-mini")
foundry_plugin.add_function("summarize_text", model="qwen2.5-0.5b")

kernel.add_plugin(foundry_plugin, plugin_name="foundry_tools")

# സെമാന്റിക് കർണൽ വർക്ക്‌ഫ്ലോകളിൽ ഉപയോഗിക്കുക
result = await kernel.invoke(
    "foundry_tools", 
    "analyze_code",
    code="def hello(): print('world')",
    language="python"
)

FastAPI സംയോജനം

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from foundry_tools.rest import FoundryRESTFramework

app = FastAPI(title="Foundry Local Tools API")

# ഫൗണ്ട്രി REST ഫ്രെയിംവർക്ക് ആരംഭിക്കുക
foundry_framework = FoundryRESTFramework()

# ലഭ്യമായ എല്ലാ ടൂളുകളും സ്വയം രജിസ്റ്റർ ചെയ്യുക
await foundry_framework.auto_register_tools([
    "code_analyzer",
    "content_summarizer", 
    "data_processor",
    "research_assistant"
])

# ഫൗണ്ട്രി എന്റ്പോയിന്റുകൾ മൗണ്ട് ചെയ്യുക
app.include_router(
    foundry_framework.get_router(),
    prefix="/api/v1/foundry",
    tags=["foundry-tools"]
)

# ഫൗണ്ട്രി ടൂളുകൾ ഉപയോഗിച്ച് കസ്റ്റം എന്റ്പോയിന്റ്
class AnalysisRequest(BaseModel):
    code: str
    language: str = "python"

@app.post("/api/v1/analyze")
async def analyze_code_endpoint(request: AnalysisRequest):
    try:
        result = await foundry_framework.call_tool(
            "code_analyzer",
            code=request.code,
            language=request.language
        )
        return {"success": True, "analysis": result}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

# ഹെൽത്ത് ചെക്ക് എന്റ്പോയിന്റ്
@app.get("/api/v1/health")
async def health_check():
    status = await foundry_framework.get_health_status()
    return {
        "foundry_status": status.foundry_running,
        "active_models": status.loaded_models,
        "available_tools": status.available_tools
    }

കമാൻഡ്-ലൈൻ സംയോജനം

import typer
from rich.console import Console
from rich.table import Table
from foundry_tools.cli import FoundryCLI

app = typer.Typer(name="foundry-tools")
console = Console()
foundry_cli = FoundryCLI()

@app.command()
async def analyze(
    file_path: str = typer.Argument(..., help="Path to code file"),
    language: str = typer.Option("python", help="Programming language"),
    output: str = typer.Option("table", help="Output format (table, json, yaml)")
):
    """Analyze code file using Foundry Local."""
    
    try:
        with open(file_path, 'r') as f:
            code = f.read()
        
        result = await foundry_cli.call_tool(
            "code_analyzer",
            code=code,
            language=language
        )
        
        if output == "table":
            table = Table(title=f"Code Analysis: {file_path}")
            table.add_column("Metric", style="cyan")
            table.add_column("Value", style="magenta")
            
            for key, value in result.items():
                table.add_row(key, str(value))
            
            console.print(table)
        
        elif output == "json":
            console.print_json(data=result)
        
        else:
            console.print(result)
            
    except Exception as e:
        console.print(f"[red]Error: {e}[/red]")
        raise typer.Exit(1)

@app.command()
async def list_tools():
    """List all available Foundry tools."""
    
    tools = await foundry_cli.list_available_tools()
    
    table = Table(title="Available Foundry Tools")
    table.add_column("Name", style="cyan")
    table.add_column("Description", style="white")
    table.add_column("Model", style="yellow")
    
    for tool in tools:
        table.add_row(
            tool["name"],
            tool["description"][:50] + "..." if len(tool["description"]) > 50 else tool["description"],
            tool["model"]
        )
    
    console.print(table)

if __name__ == "__main__":
    app()

പുരോഗമന മാതൃകകൾ

1. ടൂൾ സംയോജനം

from foundry_tools import CompositeFoundryTool

@CompositeFoundryTool(
    name="full_code_review",
    description="Comprehensive code review using multiple analysis tools"
)
async def comprehensive_code_review(code: str, language: str = "python") -> Dict[str, Any]:
    """Perform comprehensive code review using multiple tools."""
    
    # പാരലൽ ആയി നിരവധി വിശകലനങ്ങൾ നടത്തുക
    analyses = await asyncio.gather(
        call_tool("code_analyzer", code=code, language=language),
        call_tool("security_scanner", code=code, language=language),
        call_tool("performance_analyzer", code=code, language=language),
        call_tool("style_checker", code=code, language=language)
    )
    
    # ഫലങ്ങൾ സംയോജിപ്പിക്കുക
    return await call_tool("analysis_synthesizer", analyses=analyses)

2. കോൺടെക്സ്റ്റ്-അവേർ ടൂളുകൾ

from foundry_tools.context import ContextAwareFoundryTool

class ProjectAnalyzerTool(ContextAwareFoundryTool):
    """Analyze entire project with context awareness."""
    
    async def execute(self, project_path: str, analysis_depth: str = "shallow") -> Dict[str, Any]:
        """Analyze project with full context."""
        
        # പ്രോജക്ട് സാന്ദർഭ്യം നിർമ്മിക്കുക
        context = await self.build_project_context(project_path)
        
        # സാന്ദർഭ്യത്തോടെ വിശകലനം ചെയ്യുക
        return await self.foundry_call_with_context({
            "prompt": f"Analyze this {context.language} project",
            "context": context.to_dict(),
            "analysis_depth": analysis_depth
        })
    
    async def build_project_context(self, project_path: str) -> ProjectContext:
        """Build comprehensive project context."""
        # നടപ്പാക്കൽ ഇവിടെ
        pass

3. ടൂൾ ചെയിനിംഗ്

from foundry_tools.chains import FoundryToolChain

# ഡോക്യുമെന്റ് പ്രോസസ്സിംഗിനുള്ള ഒരു ടൂൾ ചെയിൻ നിർവചിക്കുക
doc_processing_chain = FoundryToolChain([
    ("extract_text", {"input": "document_path"}),
    ("summarize_content", {"input": "extracted_text", "style": "outline"}),
    ("generate_keywords", {"input": "summary"}),
    ("create_metadata", {"input": ["summary", "keywords"]})
])

# ചെയിൻ പ്രവർത്തിപ്പിക്കുക
result = await doc_processing_chain.execute({
    "document_path": "/path/to/document.pdf"
})

പ്രകടന മെച്ചപ്പെടുത്തൽ

1. കാഷിംഗ് തന്ത്രങ്ങൾ

from foundry_tools.cache import CacheConfig, CacheStrategy

cache_config = CacheConfig(
    strategy=CacheStrategy.LRU,
    max_size=1000,
    ttl=3600,  # 1 മണിക്കൂർ
    key_generator="content_hash"
)

# പ്രത്യേക ഉപകരണങ്ങൾക്ക് അപേക്ഷിക്കുക
@FoundryTool(
    name="cached_analyzer",
    cache_config=cache_config
)
async def cached_code_analyzer(code: str) -> Dict[str, Any]:
    # കാഷിംഗ് ഉപയോഗിച്ച് ലാഭം ലഭിക്കുന്ന ചെലവേറിയ വിശകലനം
    pass

2. മോഡൽ പൂൾ മാനേജ്മെന്റ്

from foundry_tools.pool import ModelPoolConfig

pool_config = ModelPoolConfig(
    models={
        "phi-4-mini": {"instances": 2, "priority": "high"},
        "qwen2.5-coder-0.5b": {"instances": 1, "priority": "medium"},
        "phi-3.5-mini": {"instances": 1, "priority": "low"}
    },
    load_balancing="round_robin",
    health_check_interval=30
)

# ടൂൾ രജിസ്ട്രി പൂലുമായി കോൺഫിഗർ ചെയ്യുക
registry = FoundryToolRegistry(model_pool_config=pool_config)

3. ബാച്ച് പ്രോസസ്സിംഗ്

from foundry_tools.batch import BatchProcessor

@BatchProcessor(
    batch_size=10,
    timeout=60,
    parallel_batches=3
)
async def batch_code_analysis(code_files: List[str]) -> List[Dict[str, Any]]:
    """Process multiple code files in batches."""
    results = []
    
    for code_file in code_files:
        with open(code_file, 'r') as f:
            code = f.read()
        
        result = await call_tool("code_analyzer", code=code)
        results.append(result)
    
    return results

നിരീക്ഷണവും ദൃശ്യവൽക്കരണവും

1. ടൂൾ മെട്രിക്‌സ്

from foundry_tools.monitoring import ToolMetrics

# സ്വയം പ്രവർത്തിക്കുന്ന മെട്രിക്‌സ് ശേഖരണം
metrics = await ToolMetrics.get_tool_performance("code_analyzer")
print(f"Average execution time: {metrics.avg_execution_time}s")
print(f"Success rate: {metrics.success_rate}%")
print(f"Cache hit rate: {metrics.cache_hit_rate}%")

2. ഹെൽത്ത് നിരീക്ഷണം

from foundry_tools.health import HealthMonitor

health_monitor = HealthMonitor()

# ഉപകരണത്തിന്റെ ആരോഗ്യനില നിരീക്ഷിക്കുക
health_status = await health_monitor.check_all_tools()
print(f"Healthy tools: {health_status.healthy_count}")
print(f"Failed tools: {health_status.failed_tools}")

3. ഉപയോഗ വിശകലനം

from foundry_tools.analytics import UsageAnalytics

analytics = UsageAnalytics()

# ഉപകരണ ഉപയോഗ പാറ്റേണുകൾ ട്രാക്ക് ചെയ്യുക
usage_report = await analytics.generate_usage_report(
    start_date="2024-01-01",
    end_date="2024-01-31"
)

print(f"Most used tool: {usage_report.most_used_tool}")
print(f"Peak usage time: {usage_report.peak_usage_time}")

പഠന ഫലങ്ങൾ

ഈ സാമ്പിൾ പൂർത്തിയാക്കിയ ശേഷം, നിങ്ങൾക്ക് മനസ്സിലാകും:

  1. ടൂൾ സംയോജനം മാതൃകകൾ

    • ഫംഗ്ഷൻ അടിസ്ഥാനമാക്കിയും ക്ലാസ് അടിസ്ഥാനമാക്കിയും ടൂൾ ഡിസൈൻ
    • Microsoft Foundry Local സംയോജനം മാതൃകകൾ
    • സ്കീമാ സാധുതയും ടൈപ്പ് സുരക്ഷയും
    • പിശക് കൈകാര്യം ചെയ്യലും പുനരുദ്ധാരണം

  2. ഫ്രെയിംവർക്ക് സംയോജനം

    • LangChain ടൂൾ വികസനം
    • Semantic Kernel ഫംഗ്ഷൻ സംയോജനം
    • REST API ഫ്രെയിംവർക്ക് സംയോജനം
    • CLI ആപ്ലിക്കേഷൻ വികസനം

  3. പ്രൊഡക്ഷൻ പരിഗണനകൾ

    • പ്രകടന മെച്ചപ്പെടുത്തൽ തന്ത്രങ്ങൾ
    • കാഷിംഗ്, റിസോഴ്‌സ് മാനേജ്മെന്റ്
    • നിരീക്ഷണവും ദൃശ്യവൽക്കരണവും
    • സുരക്ഷയും സാധുതയും

  4. പുരോഗമന ടൂൾ മാതൃകകൾ

    • ടൂൾ സംയോജനം, ചെയിനിംഗ്
    • കോൺടെക്സ്റ്റ്-അവേർ പ്രോസസ്സിംഗ്
    • ബാച്ച്, സ്ട്രീമിംഗ് ഓപ്പറേഷനുകൾ
    • കസ്റ്റം സംയോജനം വികസനം

അടുത്ത ഘട്ടങ്ങൾ

  • സംയോജനം പ്രോജക്ടുകൾ: നിങ്ങളുടെ ഇഷ്ടപ്പെട്ട ഫ്രെയിംവർക്കുകളുമായി കസ്റ്റം സംയോജനം നിർമ്മിക്കുക
  • ടൂൾ വികസനം: നിങ്ങളുടെ ഡൊമെയ്‌നിനായി പ്രത്യേക ടൂളുകൾ സൃഷ്ടിക്കുക
  • പ്രകടന ട്യൂണിംഗ്: നിങ്ങളുടെ പ്രത്യേക ഉപയോഗ കേസുകൾക്കായി മെച്ചപ്പെടുത്തുക
  • പ്രൊഡക്ഷൻ ഡിപ്ലോയ്മെന്റ്: എന്റർപ്രൈസ് ഉപയോഗത്തിനായി ടൂളുകൾ സ്കെയിൽ ചെയ്യുക

സംഭാവന

സംഭാവന നിർദ്ദേശങ്ങൾക്കായി പ്രധാന റിപോസിറ്ററി മാർഗ്ഗനിർദ്ദേശങ്ങൾ കാണുക.

ലൈസൻസ്

ഈ സാമ്പിൾ Microsoft Foundry Local പ്രോജക്ടിന്റെ സമാനമായ ലൈസൻസ് പിന്തുടരുന്നു.

അസൂയാ:
ഈ രേഖ AI വിവർത്തന സേവനം Co-op Translator ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.