Nous proposons dans cette thèse une architecture pour le raisonnement incrémental sur des flux de triples. Afin de passer à l’échelle, elle est conçue sous la forme de modules indépendants, permettant l’exécution parallèle du raisonnement. Plusieurs instances d’une même règle peuvent être exécutées simultanément afin d’améliorer les performances. Nous avons également concentré nos efforts pour limiter la dispersion des doublons dans le système, problème récurrent du raisonnement. Pour cela, un triplestore partagé permet à chaque module de filtrer au plus tôt les doublons. La structure de notre architecture, organisée en modules indépendants par lesquels transitent les triples, lui permet de recevoir en entrée des flux de triples. Enfin, notre architecture est indépendante du fragment utilisé. Nous présentons trois modes d’inférence pour notre architecture. Le premier consiste à inférer l’ensemble des connaissances implicites le plus rapidement possible. Le second priorise l'inférence de certaines connaissances prédéterminées. Le troisième vise à maximiser la quantité de triples inférés par seconde. Nous avons implémenté l’architecture présentée à travers Slider, un raisonneur incrémental prenant nativement en charge les fragments ρdf et RDFS. Il peut être facilement étendu à des fragments plus complexes. Nos expérimentations ont montré une amélioration des performances de plus de 65% par rapport au raisonneur OWLIM-SE. Nous avons également mené des tests montrant que l’utilisation du raisonnement incrémental avec Slider apporte un avantage systématique aux performances par rapport au raisonnement par lots, quels que soient l’ontologie utilisée et le fragment appliqué / In this thesis, we propose an architecture for incremental reasoning on triple streams. To ensure scalability, it is composed of independent modules; thus allowing parallel reasoning. That is, several instances of a same rule can be simultaneously executed to enhance performance. We also focused our efforts to limit the duplicates spreading in the system, a recurrent issue for reasoning. To achieve this, we design a shared triplestore which allows each module to filter duplicates as soon as possible. The triples passes through the different independent modules of the architecture allows the reasoner to receive triple streams as input. Finally, our architecture is of agnostic nature regarding the fragment used for the inference. We also present three inference modes for our architecture: the first one infers all the implicit knowledge as fast as possible; the second mode should be used when the priority has to be defined for the inference of a specific type of knowledge; the third one proposes to maximize the amount of triples inferred per second. We implemented this architecture through Slider, an incremental reasoning natively supporting the fragments ρdf and RDFS: It can easily be extended to more complex fragments. Our experimentations show a 65% improvement over the reasoner OWLIM-SE. However, the recently published reasoner RDFox exhibits better performance, although this one does not provide prioritized inference. We also conducted experimentations showing that the use of incremental reasoning over batch-based reasoning offers systematically better performance for all the ontologies and fragments used