feat: prepare for release 0.8

chr-hertel · chr-hertel · commit 7887f974958a · 2024-10-20T00:00:03.000+02:00
diff --git a/README.md b/README.md
@@ -14,31 +14,26 @@ composer require php-llm/llm-chain-bundle
 # config/packages/llm_chain.yaml
 llm_chain:
     platforms:
+        default:
+            openai:
+                api_key: '%env(OPENAI_API_KEY)%'
         azure_gpt:
-            type: 'azure'
-            base_url: '%env(AZURE_OPENAI_BASEURL)%'
-            deployment: '%env(AZURE_OPENAI_GPT)%'
-            api_key: '%env(AZURE_OPENAI_KEY)%'
-            version: '%env(AZURE_OPENAI_VERSION)%'
+            azure:
+                base_url: '%env(AZURE_OPENAI_BASEURL)%'
+                deployment: '%env(AZURE_OPENAI_GPT)%'
+                api_key: '%env(AZURE_OPENAI_KEY)%'
+                version: '%env(AZURE_OPENAI_VERSION)%'
         azure_embeddings:
-            type: 'azure'
-            base_url: '%env(AZURE_OPENAI_BASEURL)%'
-            deployment: '%env(AZURE_OPENAI_EMBEDDINGS)%'
-            api_key: '%env(AZURE_OPENAI_KEY)%'
-            version: '%env(AZURE_OPENAI_VERSION)%'
-        openai:
-            type: 'openai'
-            api_key: '%env(OPENAI_API_KEY)%'
-    llms:
-        azure_gpt:
+            azure:
+                base_url: '%env(AZURE_OPENAI_BASEURL)%'
+                deployment: '%env(AZURE_OPENAI_EMBEDDINGS)%'
+                api_key: '%env(AZURE_OPENAI_KEY)%'
+                version: '%env(AZURE_OPENAI_VERSION)%'
+    chains:
+        default:
             platform: 'azure_gpt'
-        original_gpt:
-            platform: 'openai'
-    embeddings:
-        azure_embeddings:
-            platform: 'azure_embeddings'
-        original_embeddings:
-            platform: 'openai'
+            model: 'gpt'
+            version: 'gpt-3.5-turbo'
     stores:
         azure_search:
             engine: 'azure-search'
@@ -99,18 +94,18 @@ services:
         autowire: true
         autoconfigure: true
 
-    PhpLlm\LlmChain\ToolBox\Tool\Clock: ~
-    PhpLlm\LlmChain\ToolBox\Tool\OpenMeteo: ~
-    PhpLlm\LlmChain\ToolBox\Tool\SerpApi:
+    PhpLlm\LlmChain\Chain\ToolBox\Tool\Clock: ~
+    PhpLlm\LlmChain\Chain\ToolBox\Tool\OpenMeteo: ~
+    PhpLlm\LlmChain\Chain\ToolBox\Tool\SerpApi:
         $apiKey: '%env(SERP_API_KEY)%'
-    PhpLlm\LlmChain\ToolBox\Tool\SimilaritySearch: ~
-    PhpLlm\LlmChain\ToolBox\Tool\Wikipedia: ~
-    PhpLlm\LlmChain\ToolBox\Tool\YouTubeTranscriber: ~
+    PhpLlm\LlmChain\Chain\ToolBox\Tool\SimilaritySearch: ~
+    PhpLlm\LlmChain\Chain\ToolBox\Tool\Wikipedia: ~
+    PhpLlm\LlmChain\Chain\ToolBox\Tool\YouTubeTranscriber: ~
 ```
 
 Custom tools can be registered by using the `#[AsTool]` attribute:
 ```php
-use PhpLlm\LlmChain\ToolBox\AsTool;
+use PhpLlm\LlmChain\Chain\ToolBox\Attribute\AsTool;
 
 #[AsTool('company_name', 'Provides the name of your company')]
 final class CompanyName
diff --git a/src/DependencyInjection/Configuration.php b/src/DependencyInjection/Configuration.php
@@ -16,34 +16,50 @@ public function getConfigTreeBuilder(): TreeBuilder
 
         $rootNode
             ->children()
-                ->arrayNode('platforms')
-                    ->normalizeKeys(false)
-                    ->useAttributeAsKey('name')
-                    ->arrayPrototype()
-                        ->children()
-                            ->enumNode('type')->values(['openai', 'azure'])->isRequired()->end()
-                            ->scalarNode('api_key')->isRequired()->end()
-                            ->scalarNode('base_url')->end()
-                            ->scalarNode('deployment')->end()
-                            ->scalarNode('version')->end()
+                ->arrayNode('platform')
+                    ->children()
+                        ->arrayNode('openai')
+                            ->children()
+                                ->scalarNode('api_key')->isRequired()->end()
+                            ->end()
+                        ->end()
+                        ->arrayNode('azure')
+                            ->children()
+                                ->scalarNode('api_key')->isRequired()->end()
+                                ->scalarNode('base_url')->isRequired()->end()
+                                ->scalarNode('deployment')->isRequired()->end()
+                                ->scalarNode('version')->isRequired()->end()
+                            ->end()
                         ->end()
                     ->end()
                 ->end()
-                ->arrayNode('llms')
+                ->arrayNode('chains')
                     ->normalizeKeys(false)
                     ->useAttributeAsKey('name')
                     ->arrayPrototype()
                         ->children()
-                            ->scalarNode('platform')->end()
+                            ->arrayNode('model')
+                                ->children()
+                                    ->scalarNode('name')->isRequired()->end()
+                                    ->scalarNode('version')->defaultNull()->end()
+                                    ->arrayNode('options')->end()
+                                ->end()
+                            ->end()
                         ->end()
                     ->end()
                 ->end()
-                ->arrayNode('embeddings')
+                ->arrayNode('embedder')
                     ->normalizeKeys(false)
                     ->useAttributeAsKey('name')
                     ->arrayPrototype()
                         ->children()
-                            ->scalarNode('platform')->end()
+                            ->arrayNode('model')
+                                ->children()
+                                    ->scalarNode('name')->isRequired()->end()
+                                    ->scalarNode('version')->defaultNull()->end()
+                                    ->arrayNode('options')->end()
+                                ->end()
+                            ->end()
                         ->end()
                     ->end()
                 ->end()
@@ -71,6 +87,7 @@ public function getConfigTreeBuilder(): TreeBuilder
                             ->scalarNode('top_k')->end()
                         ->end()
                     ->end()
+                ->end()
             ->end()
         ;
 
diff --git a/src/DependencyInjection/LlmChainExtension.php b/src/DependencyInjection/LlmChainExtension.php
@@ -4,24 +4,27 @@
 
 namespace PhpLlm\LlmChainBundle\DependencyInjection;
 
+use PhpLlm\LlmChain\Bridge\Anthropic\Claude;
+use PhpLlm\LlmChain\Bridge\Azure\Store\SearchStore as AzureSearchStore;
+use PhpLlm\LlmChain\Bridge\ChromaDB\Store as ChromaDBStore;
+use PhpLlm\LlmChain\Bridge\Meta\Llama;
+use PhpLlm\LlmChain\Bridge\MongoDB\Store as MongoDBStore;
+use PhpLlm\LlmChain\Bridge\OpenAI\Embeddings;
+use PhpLlm\LlmChain\Bridge\OpenAI\Embeddings\ModelClient as OpenAIEmbeddingsModelClient;
+use PhpLlm\LlmChain\Bridge\OpenAI\GPT;
+use PhpLlm\LlmChain\Bridge\OpenAI\GPT\ModelClient as OpenAIGPTModelClient;
+use PhpLlm\LlmChain\Bridge\Pinecone\Store as PineconeStore;
+use PhpLlm\LlmChain\Bridge\Voyage\Voyage;
+use PhpLlm\LlmChain\Chain;
 use PhpLlm\LlmChain\Chain\InputProcessor;
 use PhpLlm\LlmChain\Chain\OutputProcessor;
-use PhpLlm\LlmChain\EmbeddingsModel;
-use PhpLlm\LlmChain\LanguageModel;
-use PhpLlm\LlmChain\OpenAI\Model\Embeddings;
-use PhpLlm\LlmChain\OpenAI\Model\Gpt;
-use PhpLlm\LlmChain\OpenAI\Platform;
-use PhpLlm\LlmChain\OpenAI\Platform\Azure as AzurePlatform;
-use PhpLlm\LlmChain\OpenAI\Platform\OpenAI as OpenAIPlatform;
-use PhpLlm\LlmChain\Store\Azure\SearchStore as AzureSearchStore;
-use PhpLlm\LlmChain\Store\ChromaDB\Store as ChromaDBStore;
-use PhpLlm\LlmChain\Store\MongoDB\Store as MongoDBStore;
-use PhpLlm\LlmChain\Store\Pinecone\Store as PineconeStore;
+use PhpLlm\LlmChain\Chain\ToolBox\Attribute\AsTool;
+use PhpLlm\LlmChain\Embedder;
+use PhpLlm\LlmChain\Platform\ModelClient;
+use PhpLlm\LlmChain\Platform\ResponseConverter;
 use PhpLlm\LlmChain\Store\StoreInterface;
 use PhpLlm\LlmChain\Store\VectorStoreInterface;
-use PhpLlm\LlmChain\ToolBox\Attribute\AsTool;
 use PhpLlm\LlmChainBundle\Profiler\DataCollector;
-use PhpLlm\LlmChainBundle\Profiler\TraceableLanguageModel;
 use PhpLlm\LlmChainBundle\Profiler\TraceableToolBox;
 use Symfony\Component\Config\FileLocator;
 use Symfony\Component\DependencyInjection\ChildDefinition;
@@ -41,25 +44,27 @@ public function load(array $configs, ContainerBuilder $container): void
         $configuration = new Configuration();
         $config = $this->processConfiguration($configuration, $configs);
 
-        foreach ($config['platforms'] as $platformName => $platform) {
-            $this->processPlatformConfig($platformName, $platform, $container);
-        }
-        if (1 === count($config['platforms']) && isset($platformName)) {
-            $container->setAlias(Platform::class, 'llm_chain.platform.'.$platformName);
+        if (isset($config['platform'])) {
+            if (1 !== count($config['platform'])) {
+                throw new \InvalidArgumentException('Only one platform at a time is supported.');
+            }
+
+            $type = array_keys($config['platform']);
+            $this->processPlatformConfig($type[0], $config['platform'][$type[0]], $container);
         }
 
-        foreach ($config['llms'] as $llmName => $llm) {
-            $this->processLlmConfig($llmName, $llm, $container);
+        foreach ($config['chains'] as $chainName => $chain) {
+            $this->processChainConfig($chainName, $chain, $container);
         }
-        if (1 === count($config['llms']) && isset($llmName)) {
-            $container->setAlias(LanguageModel::class, 'llm_chain.llm.'.$llmName);
+        if (1 === count($config['chains']) && isset($chainName)) {
+            $container->setAlias(Chain::class, 'llm_chain.chain.'.$chainName);
         }
 
-        foreach ($config['embeddings'] as $embeddingsName => $embeddings) {
-            $this->processEmbeddingsConfig($embeddingsName, $embeddings, $container);
+        foreach ($config['embedder'] as $embedderName => $embedder) {
+            $this->processEmbedderConfig($embedderName, $embedder, $container);
         }
-        if (1 === count($config['embeddings']) && isset($embeddingsName)) {
-            $container->setAlias(EmbeddingsModel::class, 'llm_chain.embeddings.'.$embeddingsName);
+        if (1 === count($config['embedder']) && isset($embedderName)) {
+            $container->setAlias(Embedder::class, 'llm_chain.embedder.'.$chainName);
         }
 
         foreach ($config['stores'] as $storeName => $store) {
@@ -82,6 +87,10 @@ public function load(array $configs, ContainerBuilder $container): void
             ->addTag('llm_chain.chain.input_processor');
         $container->registerForAutoconfiguration(OutputProcessor::class)
             ->addTag('llm_chain.chain.output_processor');
+        $container->registerForAutoconfiguration(ModelClient::class)
+            ->addTag('llm_chain.platform.model_client');
+        $container->registerForAutoconfiguration(ResponseConverter::class)
+            ->addTag('llm_chain.platform.response_converter');
 
         if (false === $container->getParameter('kernel.debug')) {
             $container->removeDefinition(DataCollector::class);
@@ -92,63 +101,65 @@ public function load(array $configs, ContainerBuilder $container): void
     /**
      * @param array<string, mixed> $platform
      */
-    private function processPlatformConfig(string $name, array $platform, ContainerBuilder $container): void
+    private function processPlatformConfig(string $type, array $platform, ContainerBuilder $container): void
     {
-        if ('openai' === $platform['type']) {
-            $definition = new ChildDefinition(OpenAIPlatform::class);
-            $definition
+        if ('openai' === $type) {
+            $container->getDefinition(OpenAIEmbeddingsModelClient::class)
                 ->replaceArgument('$apiKey', $platform['api_key']);
 
-            $container->setDefinition('llm_chain.platform.'.$name, $definition);
+            $container->getDefinition(OpenAIGPTModelClient::class)
+                ->replaceArgument('$apiKey', $platform['api_key']);
 
             return;
         }
 
-        if ('azure' === $platform['type']) {
-            $definition = new ChildDefinition(AzurePlatform::class);
-            $definition
-                ->replaceArgument('$baseUrl', $platform['base_url'])
-                ->replaceArgument('$deployment', $platform['deployment'])
-                ->replaceArgument('$apiKey', $platform['api_key'])
-                ->replaceArgument('$apiVersion', $platform['version']);
-
-            $container->setDefinition('llm_chain.platform.'.$name, $definition);
-        }
+        // TODO: Azure, Replicate, Ollama, etc.
+        throw new \InvalidArgumentException(sprintf('Platform "%s" is not supported for configuration via bundle at this point.', $type));
     }
 
-    /**
-     * @param array<string, mixed> $llm
-     */
-    private function processLlmConfig(string $name, array $llm, ContainerBuilder $container): void
+    private function processChainConfig(string $name, array $config, ContainerBuilder $container): void
     {
-        $platform = isset($llm['platform']) ? 'llm_chain.platform.'.$llm['platform'] : Platform::class;
-
-        $definition = new ChildDefinition(Gpt::class);
-        $definition->replaceArgument('$platform', new Reference($platform));
+        ['name' => $modelName, 'version' => $version, 'options' => $options] = $config['model'];
+
+        $llmClass = match (strtolower($modelName)) {
+            'gpt' => GPT::class,
+            'claude' => Claude::class,
+            'llama' => Llama::class,
+            default => throw new \InvalidArgumentException(sprintf('Model "%s" is not supported.', $modelName)),
+        };
+        $llmDefinition = (new Definition($llmClass))
+            ->setArguments([
+                '$version' => $version,
+                '$options' => $options,
+            ]);
+        $container->setDefinition('llm_chain.chain.'.$name.'.llm', $llmDefinition);
 
-        $container->setDefinition('llm_chain.llm.'.$name, $definition);
+        $definition = (new ChildDefinition('llm_chain.chain.abstract'))
+            ->replaceArgument('$llm', new Reference('llm_chain.chain.'.$name.'.llm'));
 
-        if ($container->getParameter('kernel.debug')) {
-            $traceable = new Definition(TraceableLanguageModel::class);
-            $traceable->setDecoratedService('llm_chain.llm.'.$name);
-            $traceable->addTag('llm_chain.traceable_llm');
-            $traceable->setArgument('$llm', new Reference('llm_chain.llm.'.$name.'.debug.inner'));
-            $traceable->setArgument('$name', $name);
-            $container->setDefinition('llm_chain.llm.'.$name.'.debug', $traceable);
-        }
+        $container->setDefinition('llm_chain.chain.'.$name, $definition);
     }
 
-    /**
-     * @param array<string, mixed> $embeddings
-     */
-    private function processEmbeddingsConfig(string $name, array $embeddings, ContainerBuilder $container): void
+    private function processEmbedderConfig(int|string $name, mixed $config, ContainerBuilder $container)
     {
-        $platform = isset($embeddings['platform']) ? 'llm_chain.platform.'.$embeddings['platform'] : Platform::class;
+        ['name' => $modelName, 'version' => $version, 'options' => $options] = $config['model'];
+
+        $modelClass = match (strtolower($modelName)) {
+            'openai' => Embeddings::class,
+            'voyage' => Voyage::class,
+            default => throw new \InvalidArgumentException(sprintf('Model "%s" is not supported.', $modelName)),
+        };
+        $modelDefinition = (new Definition($modelClass))
+            ->setArguments([
+                '$version' => $version,
+                '$options' => $options,
+            ]);
+        $container->setDefinition('llm_chain.embedder.'.$name.'.embeddings', $modelDefinition);
 
-        $definition = new ChildDefinition(Embeddings::class);
-        $definition->replaceArgument('$platform', new Reference($platform));
+        $definition = (new ChildDefinition('llm_chain.embedder.abstract'))
+            ->replaceArgument('$embeddings', new Reference('llm_chain.embedder.'.$name.'.embeddings'));
 
-        $container->setDefinition('llm_chain.embeddings.'.$name, $definition);
+        $container->setDefinition('llm_chain.embedder.'.$name, $definition);
     }
 
     /**
diff --git a/src/Resources/config/services.php b/src/Resources/config/services.php
